/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/remote.py

  • Committer: Andrew Bennetts
  • Date: 2008-12-12 03:53:56 UTC
  • mto: This revision was merged to the branch mainline in revision 3900.
  • Revision ID: andrew.bennetts@canonical.com-20081212035356-uqcu89gy4nqf017x
Fix compilation error in _dirstate_helpers_c on SunOS/Solaris. (Jari Aalto)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
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.
16
19
 
17
20
import bz2
18
21
 
19
22
from bzrlib import (
20
 
    bencode,
21
23
    branch,
22
 
    bzrdir,
23
 
    config,
24
24
    debug,
25
25
    errors,
26
26
    graph,
27
 
    lock,
28
27
    lockdir,
29
28
    repository,
30
 
    repository as _mod_repository,
31
29
    revision,
32
 
    revision as _mod_revision,
33
 
    static_tuple,
34
30
    symbol_versioning,
 
31
    urlutils,
35
32
)
36
33
from bzrlib.branch import BranchReferenceFormat
37
34
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
36
from bzrlib.errors import (
40
37
    NoSuchRevision,
41
38
    SmartProtocolError,
42
39
    )
43
40
from bzrlib.lockable_files import LockableFiles
44
 
from bzrlib.smart import client, vfs, repository as smart_repo
 
41
from bzrlib.smart import client, vfs
45
42
from bzrlib.revision import ensure_null, NULL_REVISION
46
43
from bzrlib.trace import mutter, note, warning
47
44
 
54
51
            return self._client.call(method, *args)
55
52
        except errors.ErrorFromSmartServer, err:
56
53
            self._translate_error(err, **err_context)
57
 
 
 
54
        
58
55
    def _call_expecting_body(self, method, *args, **err_context):
59
56
        try:
60
57
            return self._client.call_expecting_body(method, *args)
61
58
        except errors.ErrorFromSmartServer, err:
62
59
            self._translate_error(err, **err_context)
63
 
 
64
 
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
65
 
        try:
66
 
            return self._client.call_with_body_bytes(method, args, body_bytes)
67
 
        except errors.ErrorFromSmartServer, err:
68
 
            self._translate_error(err, **err_context)
69
 
 
 
60
        
70
61
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
71
62
                                             **err_context):
72
63
        try:
74
65
                method, args, body_bytes)
75
66
        except errors.ErrorFromSmartServer, err:
76
67
            self._translate_error(err, **err_context)
77
 
 
78
 
 
79
 
def response_tuple_to_repo_format(response):
80
 
    """Convert a response tuple describing a repository format to a format."""
81
 
    format = RemoteRepositoryFormat()
82
 
    format._rich_root_data = (response[0] == 'yes')
83
 
    format._supports_tree_reference = (response[1] == 'yes')
84
 
    format._supports_external_lookups = (response[2] == 'yes')
85
 
    format._network_name = response[3]
86
 
    return format
87
 
 
88
 
 
 
68
        
89
69
# Note: RemoteBzrDirFormat is in bzrdir.py
90
70
 
91
71
class RemoteBzrDir(BzrDir, _RpcHelper):
92
72
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
73
 
94
 
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
74
    def __init__(self, transport, _client=None):
95
75
        """Construct a RemoteBzrDir.
96
76
 
97
77
        :param _client: Private parameter for testing. Disables probing and the
98
78
            use of a real bzrdir.
99
79
        """
100
 
        BzrDir.__init__(self, transport, format)
 
80
        BzrDir.__init__(self, transport, RemoteBzrDirFormat())
101
81
        # this object holds a delegated bzrdir that uses file-level operations
102
82
        # to talk to the other side
103
83
        self._real_bzrdir = None
104
 
        self._has_working_tree = None
105
 
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
106
 
        # create_branch for details.
107
 
        self._next_open_branch_result = None
108
84
 
109
85
        if _client is None:
110
86
            medium = transport.get_smart_medium()
111
87
            self._client = client._SmartClient(medium)
112
88
        else:
113
89
            self._client = _client
114
 
            if not _force_probe:
115
 
                return
116
 
 
117
 
        self._probe_bzrdir()
118
 
 
119
 
    def __repr__(self):
120
 
        return '%s(%r)' % (self.__class__.__name__, self._client)
121
 
 
122
 
    def _probe_bzrdir(self):
123
 
        medium = self._client._medium
 
90
            return
 
91
 
124
92
        path = self._path_for_remote_call(self._client)
125
 
        if medium._is_remote_before((2, 1)):
126
 
            self._rpc_open(path)
127
 
            return
128
 
        try:
129
 
            self._rpc_open_2_1(path)
130
 
            return
131
 
        except errors.UnknownSmartMethod:
132
 
            medium._remember_remote_is_before((2, 1))
133
 
            self._rpc_open(path)
134
 
 
135
 
    def _rpc_open_2_1(self, path):
136
 
        response = self._call('BzrDir.open_2.1', path)
137
 
        if response == ('no',):
138
 
            raise errors.NotBranchError(path=self.root_transport.base)
139
 
        elif response[0] == 'yes':
140
 
            if response[1] == 'yes':
141
 
                self._has_working_tree = True
142
 
            elif response[1] == 'no':
143
 
                self._has_working_tree = False
144
 
            else:
145
 
                raise errors.UnexpectedSmartServerResponse(response)
146
 
        else:
147
 
            raise errors.UnexpectedSmartServerResponse(response)
148
 
 
149
 
    def _rpc_open(self, path):
150
93
        response = self._call('BzrDir.open', path)
151
94
        if response not in [('yes',), ('no',)]:
152
95
            raise errors.UnexpectedSmartServerResponse(response)
153
96
        if response == ('no',):
154
 
            raise errors.NotBranchError(path=self.root_transport.base)
 
97
            raise errors.NotBranchError(path=transport.base)
155
98
 
156
99
    def _ensure_real(self):
157
100
        """Ensure that there is a _real_bzrdir set.
159
102
        Used before calls to self._real_bzrdir.
160
103
        """
161
104
        if not self._real_bzrdir:
162
 
            if 'hpssvfs' in debug.debug_flags:
163
 
                import traceback
164
 
                warning('VFS BzrDir access triggered\n%s',
165
 
                    ''.join(traceback.format_stack()))
166
105
            self._real_bzrdir = BzrDir.open_from_transport(
167
106
                self.root_transport, _server_formats=False)
168
 
            self._format._network_name = \
169
 
                self._real_bzrdir._format.network_name()
170
107
 
171
108
    def _translate_error(self, err, **context):
172
109
        _translate_error(err, bzrdir=self, **context)
173
110
 
174
 
    def break_lock(self):
175
 
        # Prevent aliasing problems in the next_open_branch_result cache.
176
 
        # See create_branch for rationale.
177
 
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
179
 
 
180
 
    def _vfs_cloning_metadir(self, require_stacking=False):
 
111
    def cloning_metadir(self, stacked=False):
181
112
        self._ensure_real()
182
 
        return self._real_bzrdir.cloning_metadir(
183
 
            require_stacking=require_stacking)
184
 
 
185
 
    def cloning_metadir(self, require_stacking=False):
186
 
        medium = self._client._medium
187
 
        if medium._is_remote_before((1, 13)):
188
 
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
189
 
        verb = 'BzrDir.cloning_metadir'
190
 
        if require_stacking:
191
 
            stacking = 'True'
192
 
        else:
193
 
            stacking = 'False'
194
 
        path = self._path_for_remote_call(self._client)
195
 
        try:
196
 
            response = self._call(verb, path, stacking)
197
 
        except errors.UnknownSmartMethod:
198
 
            medium._remember_remote_is_before((1, 13))
199
 
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
200
 
        except errors.UnknownErrorFromSmartServer, err:
201
 
            if err.error_tuple != ('BranchReference',):
202
 
                raise
203
 
            # We need to resolve the branch reference to determine the
204
 
            # cloning_metadir.  This causes unnecessary RPCs to open the
205
 
            # referenced branch (and bzrdir, etc) but only when the caller
206
 
            # didn't already resolve the branch reference.
207
 
            referenced_branch = self.open_branch()
208
 
            return referenced_branch.bzrdir.cloning_metadir()
209
 
        if len(response) != 3:
210
 
            raise errors.UnexpectedSmartServerResponse(response)
211
 
        control_name, repo_name, branch_info = response
212
 
        if len(branch_info) != 2:
213
 
            raise errors.UnexpectedSmartServerResponse(response)
214
 
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
216
 
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
218
 
                repo_name)
219
 
        if branch_ref == 'ref':
220
 
            # XXX: we need possible_transports here to avoid reopening the
221
 
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
223
 
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
 
            format.set_branch_format(branch_format)
225
 
        elif branch_ref == 'branch':
226
 
            if branch_name:
227
 
                format.set_branch_format(
228
 
                    branch.network_format_registry.get(branch_name))
229
 
        else:
230
 
            raise errors.UnexpectedSmartServerResponse(response)
231
 
        return format
 
113
        return self._real_bzrdir.cloning_metadir(stacked)
232
114
 
233
115
    def create_repository(self, shared=False):
234
 
        # as per meta1 formats - just delegate to the format object which may
235
 
        # be parameterised.
236
 
        result = self._format.repository_format.initialize(self, shared)
237
 
        if not isinstance(result, RemoteRepository):
238
 
            return self.open_repository()
239
 
        else:
240
 
            return result
 
116
        self._ensure_real()
 
117
        self._real_bzrdir.create_repository(shared=shared)
 
118
        return self.open_repository()
241
119
 
242
120
    def destroy_repository(self):
243
121
        """See BzrDir.destroy_repository"""
244
122
        self._ensure_real()
245
123
        self._real_bzrdir.destroy_repository()
246
124
 
247
 
    def create_branch(self, name=None):
248
 
        # as per meta1 formats - just delegate to the format object which may
249
 
        # be parameterised.
250
 
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
252
 
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
255
 
        else:
256
 
            result = real_branch
257
 
        # BzrDir.clone_on_transport() uses the result of create_branch but does
258
 
        # not return it to its callers; we save approximately 8% of our round
259
 
        # trips by handing the branch we created back to the first caller to
260
 
        # open_branch rather than probing anew. Long term we need a API in
261
 
        # bzrdir that doesn't discard result objects (like result_branch).
262
 
        # RBC 20090225
263
 
        self._next_open_branch_result = result
264
 
        return result
 
125
    def create_branch(self):
 
126
        self._ensure_real()
 
127
        real_branch = self._real_bzrdir.create_branch()
 
128
        return RemoteBranch(self, self.find_repository(), real_branch)
265
129
 
266
 
    def destroy_branch(self, name=None):
 
130
    def destroy_branch(self):
267
131
        """See BzrDir.destroy_branch"""
268
132
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
270
 
        self._next_open_branch_result = None
 
133
        self._real_bzrdir.destroy_branch()
271
134
 
272
135
    def create_workingtree(self, revision_id=None, from_branch=None):
273
136
        raise errors.NotLocalUrl(self.transport.base)
282
145
 
283
146
    def get_branch_reference(self):
284
147
        """See BzrDir.get_branch_reference()."""
285
 
        response = self._get_branch_reference()
286
 
        if response[0] == 'ref':
287
 
            return response[1]
 
148
        path = self._path_for_remote_call(self._client)
 
149
        response = self._call('BzrDir.open_branch', path)
 
150
        if response[0] == 'ok':
 
151
            if response[1] == '':
 
152
                # branch at this location.
 
153
                return None
 
154
            else:
 
155
                # a branch reference, use the existing BranchReference logic.
 
156
                return response[1]
288
157
        else:
289
 
            return None
290
 
 
291
 
    def _get_branch_reference(self):
292
 
        path = self._path_for_remote_call(self._client)
293
 
        medium = self._client._medium
294
 
        candidate_calls = [
295
 
            ('BzrDir.open_branchV3', (2, 1)),
296
 
            ('BzrDir.open_branchV2', (1, 13)),
297
 
            ('BzrDir.open_branch', None),
298
 
            ]
299
 
        for verb, required_version in candidate_calls:
300
 
            if required_version and medium._is_remote_before(required_version):
301
 
                continue
302
 
            try:
303
 
                response = self._call(verb, path)
304
 
            except errors.UnknownSmartMethod:
305
 
                if required_version is None:
306
 
                    raise
307
 
                medium._remember_remote_is_before(required_version)
308
 
            else:
309
 
                break
310
 
        if verb == 'BzrDir.open_branch':
311
 
            if response[0] != 'ok':
312
 
                raise errors.UnexpectedSmartServerResponse(response)
313
 
            if response[1] != '':
314
 
                return ('ref', response[1])
315
 
            else:
316
 
                return ('branch', '')
317
 
        if response[0] not in ('ref', 'branch'):
318
158
            raise errors.UnexpectedSmartServerResponse(response)
319
 
        return response
320
159
 
321
160
    def _get_tree_branch(self):
322
161
        """See BzrDir._get_tree_branch()."""
323
162
        return None, self.open_branch()
324
163
 
325
 
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
327
 
        if unsupported:
 
164
    def open_branch(self, _unsupported=False):
 
165
        if _unsupported:
328
166
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
 
        if self._next_open_branch_result is not None:
330
 
            # See create_branch for details.
331
 
            result = self._next_open_branch_result
332
 
            self._next_open_branch_result = None
333
 
            return result
334
 
        response = self._get_branch_reference()
335
 
        if response[0] == 'ref':
 
167
        reference_url = self.get_branch_reference()
 
168
        if reference_url is None:
 
169
            # branch at this location.
 
170
            return RemoteBranch(self, self.find_repository())
 
171
        else:
336
172
            # a branch reference, use the existing BranchReference logic.
337
173
            format = BranchReferenceFormat()
338
 
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
340
 
        branch_format_name = response[1]
341
 
        if not branch_format_name:
342
 
            branch_format_name = None
343
 
        format = RemoteBranchFormat(network_name=branch_format_name)
344
 
        return RemoteBranch(self, self.find_repository(), format=format,
345
 
            setup_stacking=not ignore_fallbacks, name=name)
346
 
 
347
 
    def _open_repo_v1(self, path):
348
 
        verb = 'BzrDir.find_repository'
349
 
        response = self._call(verb, path)
350
 
        if response[0] != 'ok':
351
 
            raise errors.UnexpectedSmartServerResponse(response)
352
 
        # servers that only support the v1 method don't support external
353
 
        # references either.
354
 
        self._ensure_real()
355
 
        repo = self._real_bzrdir.open_repository()
356
 
        response = response + ('no', repo._format.network_name())
357
 
        return response, repo
358
 
 
359
 
    def _open_repo_v2(self, path):
 
174
            return format.open(self, _found=True, location=reference_url)
 
175
                
 
176
    def open_repository(self):
 
177
        path = self._path_for_remote_call(self._client)
360
178
        verb = 'BzrDir.find_repositoryV2'
361
 
        response = self._call(verb, path)
362
 
        if response[0] != 'ok':
363
 
            raise errors.UnexpectedSmartServerResponse(response)
364
 
        self._ensure_real()
365
 
        repo = self._real_bzrdir.open_repository()
366
 
        response = response + (repo._format.network_name(),)
367
 
        return response, repo
368
 
 
369
 
    def _open_repo_v3(self, path):
370
 
        verb = 'BzrDir.find_repositoryV3'
371
 
        medium = self._client._medium
372
 
        if medium._is_remote_before((1, 13)):
373
 
            raise errors.UnknownSmartMethod(verb)
374
179
        try:
375
180
            response = self._call(verb, path)
376
181
        except errors.UnknownSmartMethod:
377
 
            medium._remember_remote_is_before((1, 13))
378
 
            raise
379
 
        if response[0] != 'ok':
380
 
            raise errors.UnexpectedSmartServerResponse(response)
381
 
        return response, None
382
 
 
383
 
    def open_repository(self):
384
 
        path = self._path_for_remote_call(self._client)
385
 
        response = None
386
 
        for probe in [self._open_repo_v3, self._open_repo_v2,
387
 
            self._open_repo_v1]:
388
 
            try:
389
 
                response, real_repo = probe(path)
390
 
                break
391
 
            except errors.UnknownSmartMethod:
392
 
                pass
393
 
        if response is None:
394
 
            raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
395
 
        if response[0] != 'ok':
396
 
            raise errors.UnexpectedSmartServerResponse(response)
397
 
        if len(response) != 6:
 
182
            verb = 'BzrDir.find_repository'
 
183
            response = self._call(verb, path)
 
184
        if response[0] != 'ok':
 
185
            raise errors.UnexpectedSmartServerResponse(response)
 
186
        if verb == 'BzrDir.find_repository':
 
187
            # servers that don't support the V2 method don't support external
 
188
            # references either.
 
189
            response = response + ('no', )
 
190
        if not (len(response) == 5):
398
191
            raise SmartProtocolError('incorrect response length %s' % (response,))
399
192
        if response[1] == '':
400
 
            # repo is at this dir.
401
 
            format = response_tuple_to_repo_format(response[2:])
 
193
            format = RemoteRepositoryFormat()
 
194
            format.rich_root_data = (response[2] == 'yes')
 
195
            format.supports_tree_reference = (response[3] == 'yes')
 
196
            # No wire format to check this yet.
 
197
            format.supports_external_lookups = (response[4] == 'yes')
402
198
            # Used to support creating a real format instance when needed.
403
199
            format._creating_bzrdir = self
404
 
            remote_repo = RemoteRepository(self, format)
405
 
            format._creating_repo = remote_repo
406
 
            if real_repo is not None:
407
 
                remote_repo._set_real_repository(real_repo)
408
 
            return remote_repo
 
200
            return RemoteRepository(self, format)
409
201
        else:
410
202
            raise errors.NoRepositoryPresent(self)
411
203
 
412
 
    def has_workingtree(self):
413
 
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
416
 
        return self._has_working_tree
417
 
 
418
204
    def open_workingtree(self, recommend_upgrade=True):
419
 
        if self.has_workingtree():
 
205
        self._ensure_real()
 
206
        if self._real_bzrdir.has_workingtree():
420
207
            raise errors.NotLocalUrl(self.root_transport)
421
208
        else:
422
209
            raise errors.NoWorkingTree(self.root_transport.base)
425
212
        """Return the path to be used for this bzrdir in a remote call."""
426
213
        return client.remote_path_from_transport(self.root_transport)
427
214
 
428
 
    def get_branch_transport(self, branch_format, name=None):
 
215
    def get_branch_transport(self, branch_format):
429
216
        self._ensure_real()
430
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
217
        return self._real_bzrdir.get_branch_transport(branch_format)
431
218
 
432
219
    def get_repository_transport(self, repository_format):
433
220
        self._ensure_real()
443
230
 
444
231
    def needs_format_conversion(self, format=None):
445
232
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
233
        return False
450
234
 
451
235
    def clone(self, url, revision_id=None, force_new_repo=False,
454
238
        return self._real_bzrdir.clone(url, revision_id=revision_id,
455
239
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
456
240
 
457
 
    def _get_config(self):
458
 
        return RemoteBzrDirConfig(self)
 
241
    def get_config(self):
 
242
        self._ensure_real()
 
243
        return self._real_bzrdir.get_config()
459
244
 
460
245
 
461
246
class RemoteRepositoryFormat(repository.RepositoryFormat):
469
254
    the attributes rich_root_data and supports_tree_reference are set
470
255
    on a per instance basis, and are not set (and should not be) at
471
256
    the class level.
472
 
 
473
 
    :ivar _custom_format: If set, a specific concrete repository format that
474
 
        will be used when initializing a repository with this
475
 
        RemoteRepositoryFormat.
476
 
    :ivar _creating_repo: If set, the repository object that this
477
 
        RemoteRepositoryFormat was created for: it can be called into
478
 
        to obtain data like the network name.
479
257
    """
480
258
 
481
259
    _matchingbzrdir = RemoteBzrDirFormat()
482
260
 
483
 
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
485
 
        self._custom_format = None
486
 
        self._network_name = None
487
 
        self._creating_bzrdir = None
488
 
        self._supports_chks = None
489
 
        self._supports_external_lookups = None
490
 
        self._supports_tree_reference = None
491
 
        self._rich_root_data = None
492
 
 
493
 
    def __repr__(self):
494
 
        return "%s(_network_name=%r)" % (self.__class__.__name__,
495
 
            self._network_name)
496
 
 
497
 
    @property
498
 
    def fast_deltas(self):
499
 
        self._ensure_real()
500
 
        return self._custom_format.fast_deltas
501
 
 
502
 
    @property
503
 
    def rich_root_data(self):
504
 
        if self._rich_root_data is None:
505
 
            self._ensure_real()
506
 
            self._rich_root_data = self._custom_format.rich_root_data
507
 
        return self._rich_root_data
508
 
 
509
 
    @property
510
 
    def supports_chks(self):
511
 
        if self._supports_chks is None:
512
 
            self._ensure_real()
513
 
            self._supports_chks = self._custom_format.supports_chks
514
 
        return self._supports_chks
515
 
 
516
 
    @property
517
 
    def supports_external_lookups(self):
518
 
        if self._supports_external_lookups is None:
519
 
            self._ensure_real()
520
 
            self._supports_external_lookups = \
521
 
                self._custom_format.supports_external_lookups
522
 
        return self._supports_external_lookups
523
 
 
524
 
    @property
525
 
    def supports_tree_reference(self):
526
 
        if self._supports_tree_reference is None:
527
 
            self._ensure_real()
528
 
            self._supports_tree_reference = \
529
 
                self._custom_format.supports_tree_reference
530
 
        return self._supports_tree_reference
531
 
 
532
 
    def _vfs_initialize(self, a_bzrdir, shared):
533
 
        """Helper for common code in initialize."""
534
 
        if self._custom_format:
535
 
            # Custom format requested
536
 
            result = self._custom_format.initialize(a_bzrdir, shared=shared)
537
 
        elif self._creating_bzrdir is not None:
538
 
            # Use the format that the repository we were created to back
539
 
            # has.
 
261
    def initialize(self, a_bzrdir, shared=False):
 
262
        if not isinstance(a_bzrdir, RemoteBzrDir):
540
263
            prior_repo = self._creating_bzrdir.open_repository()
541
264
            prior_repo._ensure_real()
542
 
            result = prior_repo._real_repository._format.initialize(
 
265
            return prior_repo._real_repository._format.initialize(
543
266
                a_bzrdir, shared=shared)
544
 
        else:
545
 
            # assume that a_bzr is a RemoteBzrDir but the smart server didn't
546
 
            # support remote initialization.
547
 
            # We delegate to a real object at this point (as RemoteBzrDir
548
 
            # delegate to the repository format which would lead to infinite
549
 
            # recursion if we just called a_bzrdir.create_repository.
550
 
            a_bzrdir._ensure_real()
551
 
            result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
552
 
        if not isinstance(result, RemoteRepository):
553
 
            return self.open(a_bzrdir)
554
 
        else:
555
 
            return result
556
 
 
557
 
    def initialize(self, a_bzrdir, shared=False):
558
 
        # Being asked to create on a non RemoteBzrDir:
559
 
        if not isinstance(a_bzrdir, RemoteBzrDir):
560
 
            return self._vfs_initialize(a_bzrdir, shared)
561
 
        medium = a_bzrdir._client._medium
562
 
        if medium._is_remote_before((1, 13)):
563
 
            return self._vfs_initialize(a_bzrdir, shared)
564
 
        # Creating on a remote bzr dir.
565
 
        # 1) get the network name to use.
566
 
        if self._custom_format:
567
 
            network_name = self._custom_format.network_name()
568
 
        elif self._network_name:
569
 
            network_name = self._network_name
570
 
        else:
571
 
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
573
 
            reference_format = reference_bzrdir_format.repository_format
574
 
            network_name = reference_format.network_name()
575
 
        # 2) try direct creation via RPC
576
 
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
577
 
        verb = 'BzrDir.create_repository'
578
 
        if shared:
579
 
            shared_str = 'True'
580
 
        else:
581
 
            shared_str = 'False'
582
 
        try:
583
 
            response = a_bzrdir._call(verb, path, network_name, shared_str)
584
 
        except errors.UnknownSmartMethod:
585
 
            # Fallback - use vfs methods
586
 
            medium._remember_remote_is_before((1, 13))
587
 
            return self._vfs_initialize(a_bzrdir, shared)
588
 
        else:
589
 
            # Turn the response into a RemoteRepository object.
590
 
            format = response_tuple_to_repo_format(response[1:])
591
 
            # Used to support creating a real format instance when needed.
592
 
            format._creating_bzrdir = a_bzrdir
593
 
            remote_repo = RemoteRepository(a_bzrdir, format)
594
 
            format._creating_repo = remote_repo
595
 
            return remote_repo
596
 
 
 
267
        return a_bzrdir.create_repository(shared=shared)
 
268
    
597
269
    def open(self, a_bzrdir):
598
270
        if not isinstance(a_bzrdir, RemoteBzrDir):
599
271
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
600
272
        return a_bzrdir.open_repository()
601
273
 
602
 
    def _ensure_real(self):
603
 
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
605
 
                self._network_name)
606
 
 
607
 
    @property
608
 
    def _fetch_order(self):
609
 
        self._ensure_real()
610
 
        return self._custom_format._fetch_order
611
 
 
612
 
    @property
613
 
    def _fetch_uses_deltas(self):
614
 
        self._ensure_real()
615
 
        return self._custom_format._fetch_uses_deltas
616
 
 
617
 
    @property
618
 
    def _fetch_reconcile(self):
619
 
        self._ensure_real()
620
 
        return self._custom_format._fetch_reconcile
621
 
 
622
274
    def get_format_description(self):
623
 
        self._ensure_real()
624
 
        return 'Remote: ' + self._custom_format.get_format_description()
 
275
        return 'bzr remote repository'
625
276
 
626
277
    def __eq__(self, other):
627
 
        return self.__class__ is other.__class__
628
 
 
629
 
    def network_name(self):
630
 
        if self._network_name:
631
 
            return self._network_name
632
 
        self._creating_repo._ensure_real()
633
 
        return self._creating_repo._real_repository._format.network_name()
634
 
 
635
 
    @property
636
 
    def pack_compresses(self):
637
 
        self._ensure_real()
638
 
        return self._custom_format.pack_compresses
639
 
 
640
 
    @property
641
 
    def _serializer(self):
642
 
        self._ensure_real()
643
 
        return self._custom_format._serializer
644
 
 
645
 
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
278
        return self.__class__ == other.__class__
 
279
 
 
280
    def check_conversion_target(self, target_format):
 
281
        if self.rich_root_data and not target_format.rich_root_data:
 
282
            raise errors.BadConversionTarget(
 
283
                'Does not support rich root data.', target_format)
 
284
        if (self.supports_tree_reference and
 
285
            not getattr(target_format, 'supports_tree_reference', False)):
 
286
            raise errors.BadConversionTarget(
 
287
                'Does not support nested trees', target_format)
 
288
 
 
289
 
 
290
class RemoteRepository(_RpcHelper):
648
291
    """Repository accessed over rpc.
649
292
 
650
293
    For the moment most operations are performed using local transport-backed
653
296
 
654
297
    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
655
298
        """Create a RemoteRepository instance.
656
 
 
 
299
        
657
300
        :param remote_bzrdir: The bzrdir hosting this repository.
658
301
        :param format: The RemoteFormat object to use.
659
302
        :param real_repository: If not None, a local implementation of the
676
319
        self._lock_token = None
677
320
        self._lock_count = 0
678
321
        self._leave_lock = False
679
 
        # Cache of revision parents; misses are cached during read locks, and
680
 
        # write locks when no _real_repository has been set.
681
322
        self._unstacked_provider = graph.CachingParentsProvider(
682
323
            get_parent_map=self._get_parent_map_rpc)
683
324
        self._unstacked_provider.disable_cache()
693
334
        # Additional places to query for data.
694
335
        self._fallback_repositories = []
695
336
 
696
 
    @property
697
 
    def user_transport(self):
698
 
        return self.bzrdir.user_transport
699
 
 
700
 
    @property
701
 
    def control_transport(self):
702
 
        # XXX: Normally you shouldn't directly get at the remote repository
703
 
        # transport, but I'm not sure it's worth making this method
704
 
        # optional -- mbp 2010-04-21
705
 
        return self.bzrdir.get_repository_transport(None)
706
 
        
707
337
    def __str__(self):
708
338
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
339
 
711
341
 
712
342
    def abort_write_group(self, suppress_errors=False):
713
343
        """Complete a write group on the decorated repository.
714
 
 
715
 
        Smart methods perform operations in a single step so this API
 
344
        
 
345
        Smart methods peform operations in a single step so this api
716
346
        is not really applicable except as a compatibility thunk
717
347
        for older plugins that don't use e.g. the CommitBuilder
718
348
        facility.
723
353
        return self._real_repository.abort_write_group(
724
354
            suppress_errors=suppress_errors)
725
355
 
726
 
    @property
727
 
    def chk_bytes(self):
728
 
        """Decorate the real repository for now.
729
 
 
730
 
        In the long term a full blown network facility is needed to avoid
731
 
        creating a real repository object locally.
732
 
        """
733
 
        self._ensure_real()
734
 
        return self._real_repository.chk_bytes
735
 
 
736
356
    def commit_write_group(self):
737
357
        """Complete a write group on the decorated repository.
738
 
 
739
 
        Smart methods perform operations in a single step so this API
 
358
        
 
359
        Smart methods peform operations in a single step so this api
740
360
        is not really applicable except as a compatibility thunk
741
361
        for older plugins that don't use e.g. the CommitBuilder
742
362
        facility.
744
364
        self._ensure_real()
745
365
        return self._real_repository.commit_write_group()
746
366
 
747
 
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
750
 
 
751
 
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
754
 
 
755
 
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
 
        self._ensure_real()
757
 
        return self._real_repository.get_missing_parent_inventories(
758
 
            check_for_missing_texts=check_for_missing_texts)
759
 
 
760
 
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
761
 
        self._ensure_real()
762
 
        return self._real_repository.get_rev_id_for_revno(
763
 
            revno, known_pair)
764
 
 
765
 
    def get_rev_id_for_revno(self, revno, known_pair):
766
 
        """See Repository.get_rev_id_for_revno."""
767
 
        path = self.bzrdir._path_for_remote_call(self._client)
768
 
        try:
769
 
            if self._client._medium._is_remote_before((1, 17)):
770
 
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
771
 
            response = self._call(
772
 
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
773
 
        except errors.UnknownSmartMethod:
774
 
            self._client._medium._remember_remote_is_before((1, 17))
775
 
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
776
 
        if response[0] == 'ok':
777
 
            return True, response[1]
778
 
        elif response[0] == 'history-incomplete':
779
 
            known_pair = response[1:3]
780
 
            for fallback in self._fallback_repositories:
781
 
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
782
 
                if found:
783
 
                    return True, result
784
 
                else:
785
 
                    known_pair = result
786
 
            # Not found in any fallbacks
787
 
            return False, known_pair
788
 
        else:
789
 
            raise errors.UnexpectedSmartServerResponse(response)
790
 
 
791
367
    def _ensure_real(self):
792
368
        """Ensure that there is a _real_repository set.
793
369
 
794
370
        Used before calls to self._real_repository.
795
 
 
796
 
        Note that _ensure_real causes many roundtrips to the server which are
797
 
        not desirable, and prevents the use of smart one-roundtrip RPC's to
798
 
        perform complex operations (such as accessing parent data, streaming
799
 
        revisions etc). Adding calls to _ensure_real should only be done when
800
 
        bringing up new functionality, adding fallbacks for smart methods that
801
 
        require a fallback path, and never to replace an existing smart method
802
 
        invocation. If in doubt chat to the bzr network team.
803
371
        """
804
372
        if self._real_repository is None:
805
 
            if 'hpssvfs' in debug.debug_flags:
806
 
                import traceback
807
 
                warning('VFS Repository access triggered\n%s',
808
 
                    ''.join(traceback.format_stack()))
809
 
            self._unstacked_provider.missing_keys.clear()
810
373
            self.bzrdir._ensure_real()
811
374
            self._set_real_repository(
812
375
                self.bzrdir._real_bzrdir.open_repository())
839
402
        self._ensure_real()
840
403
        return self._real_repository._generate_text_key_index()
841
404
 
 
405
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
 
406
    def get_revision_graph(self, revision_id=None):
 
407
        """See Repository.get_revision_graph()."""
 
408
        return self._get_revision_graph(revision_id)
 
409
 
842
410
    def _get_revision_graph(self, revision_id):
843
411
        """Private method for using with old (< 1.2) servers to fallback."""
844
412
        if revision_id is None:
861
429
        for line in lines:
862
430
            d = tuple(line.split())
863
431
            revision_graph[d[0]] = d[1:]
864
 
 
 
432
            
865
433
        return revision_graph
866
434
 
867
 
    def _get_sink(self):
868
 
        """See Repository._get_sink()."""
869
 
        return RemoteStreamSink(self)
870
 
 
871
 
    def _get_source(self, to_format):
872
 
        """Return a source for streaming from this repository."""
873
 
        return RemoteStreamSource(self, to_format)
874
 
 
875
 
    @needs_read_lock
876
435
    def has_revision(self, revision_id):
877
 
        """True if this repository has a copy of the revision."""
878
 
        # Copy of bzrlib.repository.Repository.has_revision
879
 
        return revision_id in self.has_revisions((revision_id,))
 
436
        """See Repository.has_revision()."""
 
437
        if revision_id == NULL_REVISION:
 
438
            # The null revision is always present.
 
439
            return True
 
440
        path = self.bzrdir._path_for_remote_call(self._client)
 
441
        response = self._call('Repository.has_revision', path, revision_id)
 
442
        if response[0] not in ('yes', 'no'):
 
443
            raise errors.UnexpectedSmartServerResponse(response)
 
444
        if response[0] == 'yes':
 
445
            return True
 
446
        for fallback_repo in self._fallback_repositories:
 
447
            if fallback_repo.has_revision(revision_id):
 
448
                return True
 
449
        return False
880
450
 
881
 
    @needs_read_lock
882
451
    def has_revisions(self, revision_ids):
883
 
        """Probe to find out the presence of multiple revisions.
884
 
 
885
 
        :param revision_ids: An iterable of revision_ids.
886
 
        :return: A set of the revision_ids that were present.
887
 
        """
888
 
        # Copy of bzrlib.repository.Repository.has_revisions
889
 
        parent_map = self.get_parent_map(revision_ids)
890
 
        result = set(parent_map)
891
 
        if _mod_revision.NULL_REVISION in revision_ids:
892
 
            result.add(_mod_revision.NULL_REVISION)
 
452
        """See Repository.has_revisions()."""
 
453
        # FIXME: This does many roundtrips, particularly when there are
 
454
        # fallback repositories.  -- mbp 20080905
 
455
        result = set()
 
456
        for revision_id in revision_ids:
 
457
            if self.has_revision(revision_id):
 
458
                result.add(revision_id)
893
459
        return result
894
460
 
895
 
    def _has_same_fallbacks(self, other_repo):
896
 
        """Returns true if the repositories have the same fallbacks."""
897
 
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
899
 
        my_fb = self._fallback_repositories
900
 
        other_fb = other_repo._fallback_repositories
901
 
        if len(my_fb) != len(other_fb):
902
 
            return False
903
 
        for f, g in zip(my_fb, other_fb):
904
 
            if not f.has_same_location(g):
905
 
                return False
906
 
        return True
907
 
 
908
461
    def has_same_location(self, other):
909
 
        # TODO: Move to RepositoryBase and unify with the regular Repository
910
 
        # one; unfortunately the tests rely on slightly different behaviour at
911
 
        # present -- mbp 20090710
912
 
        return (self.__class__ is other.__class__ and
 
462
        return (self.__class__ == other.__class__ and
913
463
                self.bzrdir.transport.base == other.bzrdir.transport.base)
914
464
 
915
465
    def get_graph(self, other_repository=None):
917
467
        parents_provider = self._make_parents_provider(other_repository)
918
468
        return graph.Graph(parents_provider)
919
469
 
920
 
    @needs_read_lock
921
 
    def get_known_graph_ancestry(self, revision_ids):
922
 
        """Return the known graph for a set of revision ids and their ancestors.
923
 
        """
924
 
        st = static_tuple.StaticTuple
925
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
926
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
927
 
        return graph.GraphThunkIdsToKeys(known_graph)
928
 
 
929
470
    def gather_stats(self, revid=None, committers=None):
930
471
        """See Repository.gather_stats()."""
931
472
        path = self.bzrdir._path_for_remote_call(self._client)
991
532
    def is_write_locked(self):
992
533
        return self._lock_mode == 'w'
993
534
 
994
 
    def _warn_if_deprecated(self, branch=None):
995
 
        # If we have a real repository, the check will be done there, if we
996
 
        # don't the check will be done remotely.
997
 
        pass
998
 
 
999
535
    def lock_read(self):
1000
536
        # wrong eventually - want a local lock cache context
1001
537
        if not self._lock_mode:
1002
 
            self._note_lock('r')
1003
538
            self._lock_mode = 'r'
1004
539
            self._lock_count = 1
1005
 
            self._unstacked_provider.enable_cache(cache_misses=True)
 
540
            self._unstacked_provider.enable_cache(cache_misses=False)
1006
541
            if self._real_repository is not None:
1007
542
                self._real_repository.lock_read()
1008
 
            for repo in self._fallback_repositories:
1009
 
                repo.lock_read()
1010
543
        else:
1011
544
            self._lock_count += 1
1012
545
 
1025
558
 
1026
559
    def lock_write(self, token=None, _skip_rpc=False):
1027
560
        if not self._lock_mode:
1028
 
            self._note_lock('w')
1029
561
            if _skip_rpc:
1030
562
                if self._lock_token is not None:
1031
563
                    if token != self._lock_token:
1045
577
                self._leave_lock = False
1046
578
            self._lock_mode = 'w'
1047
579
            self._lock_count = 1
1048
 
            cache_misses = self._real_repository is None
1049
 
            self._unstacked_provider.enable_cache(cache_misses=cache_misses)
1050
 
            for repo in self._fallback_repositories:
1051
 
                # Writes don't affect fallback repos
1052
 
                repo.lock_read()
 
580
            self._unstacked_provider.enable_cache(cache_misses=False)
1053
581
        elif self._lock_mode == 'r':
1054
582
            raise errors.ReadOnlyError(self)
1055
583
        else:
1073
601
            implemented operations.
1074
602
        """
1075
603
        if self._real_repository is not None:
1076
 
            # Replacing an already set real repository.
1077
 
            # We cannot do this [currently] if the repository is locked -
1078
 
            # synchronised state might be lost.
1079
 
            if self.is_locked():
1080
 
                raise AssertionError('_real_repository is already set')
 
604
            raise AssertionError('_real_repository is already set')
1081
605
        if isinstance(repository, RemoteRepository):
1082
606
            raise AssertionError()
1083
607
        self._real_repository = repository
1084
 
        # three code paths happen here:
1085
 
        # 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1086
 
        # up stacking. In this case self._fallback_repositories is [], and the
1087
 
        # real repo is already setup. Preserve the real repo and
1088
 
        # RemoteRepository.add_fallback_repository will avoid adding
1089
 
        # duplicates.
1090
 
        # 2) new servers, RemoteBranch.open() sets up stacking, and when
1091
 
        # ensure_real is triggered from a branch, the real repository to
1092
 
        # set already has a matching list with separate instances, but
1093
 
        # as they are also RemoteRepositories we don't worry about making the
1094
 
        # lists be identical.
1095
 
        # 3) new servers, RemoteRepository.ensure_real is triggered before
1096
 
        # RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1097
 
        # and need to populate it.
1098
 
        if (self._fallback_repositories and
1099
 
            len(self._real_repository._fallback_repositories) !=
1100
 
            len(self._fallback_repositories)):
1101
 
            if len(self._real_repository._fallback_repositories):
1102
 
                raise AssertionError(
1103
 
                    "cannot cleanly remove existing _fallback_repositories")
1104
608
        for fb in self._fallback_repositories:
1105
609
            self._real_repository.add_fallback_repository(fb)
1106
610
        if self._lock_mode == 'w':
1112
616
 
1113
617
    def start_write_group(self):
1114
618
        """Start a write group on the decorated repository.
1115
 
 
1116
 
        Smart methods perform operations in a single step so this API
 
619
        
 
620
        Smart methods peform operations in a single step so this api
1117
621
        is not really applicable except as a compatibility thunk
1118
622
        for older plugins that don't use e.g. the CommitBuilder
1119
623
        facility.
1134
638
        else:
1135
639
            raise errors.UnexpectedSmartServerResponse(response)
1136
640
 
1137
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1138
641
    def unlock(self):
1139
 
        if not self._lock_count:
1140
 
            return lock.cant_unlock_not_held(self)
1141
642
        self._lock_count -= 1
1142
643
        if self._lock_count > 0:
1143
644
            return
1157
658
            # problem releasing the vfs-based lock.
1158
659
            if old_mode == 'w':
1159
660
                # Only write-locked repositories need to make a remote method
1160
 
                # call to perform the unlock.
 
661
                # call to perfom the unlock.
1161
662
                old_token = self._lock_token
1162
663
                self._lock_token = None
1163
664
                if not self._leave_lock:
1164
665
                    self._unlock(old_token)
1165
 
        # Fallbacks are always 'lock_read()' so we don't pay attention to
1166
 
        # self._leave_lock
1167
 
        for repo in self._fallback_repositories:
1168
 
            repo.unlock()
1169
666
 
1170
667
    def break_lock(self):
1171
668
        # should hand off to the network
1174
671
 
1175
672
    def _get_tarball(self, compression):
1176
673
        """Return a TemporaryFile containing a repository tarball.
1177
 
 
 
674
        
1178
675
        Returns None if the server does not support sending tarballs.
1179
676
        """
1180
677
        import tempfile
1226
723
 
1227
724
    def add_fallback_repository(self, repository):
1228
725
        """Add a repository to use for looking up data not held locally.
1229
 
 
 
726
        
1230
727
        :param repository: A repository.
1231
728
        """
1232
 
        if not self._format.supports_external_lookups:
1233
 
            raise errors.UnstackableRepositoryFormat(
1234
 
                self._format.network_name(), self.base)
 
729
        # XXX: At the moment the RemoteRepository will allow fallbacks
 
730
        # unconditionally - however, a _real_repository will usually exist,
 
731
        # and may raise an error if it's not accommodated by the underlying
 
732
        # format.  Eventually we should check when opening the repository
 
733
        # whether it's willing to allow them or not.
 
734
        #
1235
735
        # We need to accumulate additional repositories here, to pass them in
1236
736
        # on various RPC's.
1237
 
        #
1238
 
        if self.is_locked():
1239
 
            # We will call fallback.unlock() when we transition to the unlocked
1240
 
            # state, so always add a lock here. If a caller passes us a locked
1241
 
            # repository, they are responsible for unlocking it later.
1242
 
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
737
        self._fallback_repositories.append(repository)
1245
 
        # If self._real_repository was parameterised already (e.g. because a
1246
 
        # _real_branch had its get_stacked_on_url method called), then the
1247
 
        # repository to be added may already be in the _real_repositories list.
1248
 
        if self._real_repository is not None:
1249
 
            fallback_locations = [repo.user_url for repo in
1250
 
                self._real_repository._fallback_repositories]
1251
 
            if repository.user_url not in fallback_locations:
1252
 
                self._real_repository.add_fallback_repository(repository)
1253
 
 
1254
 
    def _check_fallback_repository(self, repository):
1255
 
        """Check that this repository can fallback to repository safely.
1256
 
 
1257
 
        Raise an error if not.
1258
 
 
1259
 
        :param repository: A repository to fallback to.
1260
 
        """
1261
 
        return _mod_repository.InterRepository._assert_same_model(
1262
 
            self, repository)
 
738
        # They are also seen by the fallback repository.  If it doesn't exist
 
739
        # yet they'll be added then.  This implicitly copies them.
 
740
        self._ensure_real()
1263
741
 
1264
742
    def add_inventory(self, revid, inv, parents):
1265
743
        self._ensure_real()
1266
744
        return self._real_repository.add_inventory(revid, inv, parents)
1267
745
 
1268
746
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1269
 
            parents, basis_inv=None, propagate_caches=False):
 
747
                               parents):
1270
748
        self._ensure_real()
1271
749
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1272
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1273
 
            propagate_caches=propagate_caches)
 
750
            delta, new_revision_id, parents)
1274
751
 
1275
752
    def add_revision(self, rev_id, rev, inv=None, config=None):
1276
753
        self._ensure_real()
1282
759
        self._ensure_real()
1283
760
        return self._real_repository.get_inventory(revision_id)
1284
761
 
1285
 
    def iter_inventories(self, revision_ids, ordering=None):
 
762
    def iter_inventories(self, revision_ids):
1286
763
        self._ensure_real()
1287
 
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
764
        return self._real_repository.iter_inventories(revision_ids)
1288
765
 
1289
766
    @needs_read_lock
1290
767
    def get_revision(self, revision_id):
1305
782
        self._ensure_real()
1306
783
        return self._real_repository.make_working_trees()
1307
784
 
1308
 
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
1310
 
 
1311
 
        This method is intended to be called after another repository instance
1312
 
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
1315
 
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
 
        if self._real_repository is not None:
1320
 
            self._real_repository.refresh_data()
1321
 
 
1322
785
    def revision_ids_to_search_result(self, result_set):
1323
786
        """Convert a set of revision ids to a graph SearchResult."""
1324
787
        result_parents = set()
1335
798
    @needs_read_lock
1336
799
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1337
800
        """Return the revision ids that other has that this does not.
1338
 
 
 
801
        
1339
802
        These are returned in topological order.
1340
803
 
1341
804
        revision_id: only return revision ids included by revision_id.
1343
806
        return repository.InterRepository.get(
1344
807
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
1345
808
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1347
 
            fetch_spec=None):
1348
 
        # No base implementation to use as RemoteRepository is not a subclass
1349
 
        # of Repository; so this is a copy of Repository.fetch().
1350
 
        if fetch_spec is not None and revision_id is not None:
1351
 
            raise AssertionError(
1352
 
                "fetch_spec and revision_id are mutually exclusive.")
1353
 
        if self.is_in_write_group():
1354
 
            raise errors.InternalBzrError(
1355
 
                "May not fetch while in a write group.")
1356
 
        # fast path same-url fetch operations
1357
 
        if (self.has_same_location(source)
1358
 
            and fetch_spec is None
1359
 
            and self._has_same_fallbacks(source)):
 
809
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False):
 
810
        # Not delegated to _real_repository so that InterRepository.get has a
 
811
        # chance to find an InterRepository specialised for RemoteRepository.
 
812
        if self.has_same_location(source):
1360
813
            # check that last_revision is in 'from' and then return a
1361
814
            # no-operation.
1362
815
            if (revision_id is not None and
1363
816
                not revision.is_null(revision_id)):
1364
817
                self.get_revision(revision_id)
1365
818
            return 0, []
1366
 
        # if there is no specific appropriate InterRepository, this will get
1367
 
        # the InterRepository base class, which raises an
1368
 
        # IncompatibleRepositories when asked to fetch.
1369
819
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
1371
 
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
 
820
        try:
 
821
            return inter.fetch(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts)
 
822
        except NotImplementedError:
 
823
            raise errors.IncompatibleRepositories(source, self)
1372
824
 
1373
825
    def create_bundle(self, target, base, fileobj, format=None):
1374
826
        self._ensure_real()
1387
839
        self._ensure_real()
1388
840
        return self._real_repository._get_versioned_file_checker(
1389
841
            revisions, revision_versions_cache)
1390
 
 
 
842
        
1391
843
    def iter_files_bytes(self, desired_files):
1392
844
        """See Repository.iter_file_bytes.
1393
845
        """
1394
846
        self._ensure_real()
1395
847
        return self._real_repository.iter_files_bytes(desired_files)
1396
848
 
 
849
    @property
 
850
    def _fetch_order(self):
 
851
        """Decorate the real repository for now.
 
852
 
 
853
        In the long term getting this back from the remote repository as part
 
854
        of open would be more efficient.
 
855
        """
 
856
        self._ensure_real()
 
857
        return self._real_repository._fetch_order
 
858
 
 
859
    @property
 
860
    def _fetch_uses_deltas(self):
 
861
        """Decorate the real repository for now.
 
862
 
 
863
        In the long term getting this back from the remote repository as part
 
864
        of open would be more efficient.
 
865
        """
 
866
        self._ensure_real()
 
867
        return self._real_repository._fetch_uses_deltas
 
868
 
 
869
    @property
 
870
    def _fetch_reconcile(self):
 
871
        """Decorate the real repository for now.
 
872
 
 
873
        In the long term getting this back from the remote repository as part
 
874
        of open would be more efficient.
 
875
        """
 
876
        self._ensure_real()
 
877
        return self._real_repository._fetch_reconcile
 
878
 
1397
879
    def get_parent_map(self, revision_ids):
1398
880
        """See bzrlib.Graph.get_parent_map()."""
1399
881
        return self._make_parents_provider().get_parent_map(revision_ids)
1405
887
            # We already found out that the server can't understand
1406
888
            # Repository.get_parent_map requests, so just fetch the whole
1407
889
            # graph.
1408
 
            #
1409
 
            # Note that this reads the whole graph, when only some keys are
1410
 
            # wanted.  On this old server there's no way (?) to get them all
1411
 
            # in one go, and the user probably will have seen a warning about
1412
 
            # the server being old anyhow.
1413
 
            rg = self._get_revision_graph(None)
1414
 
            # There is an API discrepancy between get_parent_map and
 
890
            # XXX: Note that this will issue a deprecation warning. This is ok
 
891
            # :- its because we're working with a deprecated server anyway, and
 
892
            # the user will almost certainly have seen a warning about the
 
893
            # server version already.
 
894
            rg = self.get_revision_graph()
 
895
            # There is an api discrepency between get_parent_map and
1415
896
            # get_revision_graph. Specifically, a "key:()" pair in
1416
897
            # get_revision_graph just means a node has no parents. For
1417
898
            # "get_parent_map" it means the node is a ghost. So fix up the
1447
928
        # TODO: Manage this incrementally to avoid covering the same path
1448
929
        # repeatedly. (The server will have to on each request, but the less
1449
930
        # work done the better).
1450
 
        #
1451
 
        # Negative caching notes:
1452
 
        # new server sends missing when a request including the revid
1453
 
        # 'include-missing:' is present in the request.
1454
 
        # missing keys are serialised as missing:X, and we then call
1455
 
        # provider.note_missing(X) for-all X
1456
931
        parents_map = self._unstacked_provider.get_cached_map()
1457
932
        if parents_map is None:
1458
933
            # Repository is not locked, so there's no cache.
1459
934
            parents_map = {}
1460
 
        # start_set is all the keys in the cache
1461
935
        start_set = set(parents_map)
1462
 
        # result set is all the references to keys in the cache
1463
936
        result_parents = set()
1464
937
        for parents in parents_map.itervalues():
1465
938
            result_parents.update(parents)
1466
939
        stop_keys = result_parents.difference(start_set)
1467
 
        # We don't need to send ghosts back to the server as a position to
1468
 
        # stop either.
1469
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1470
 
        key_count = len(parents_map)
1471
 
        if (NULL_REVISION in result_parents
1472
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1473
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1474
 
            # in our cache of "missing" keys we need to increment our key count
1475
 
            # by 1, because the reconsitituted SearchResult on the server will
1476
 
            # still consider NULL_REVISION to be an included key.
1477
 
            key_count += 1
1478
940
        included_keys = start_set.intersection(result_parents)
1479
941
        start_set.difference_update(included_keys)
1480
 
        recipe = ('manual', start_set, stop_keys, key_count)
 
942
        recipe = (start_set, stop_keys, len(parents_map))
1481
943
        body = self._serialise_search_recipe(recipe)
1482
944
        path = self.bzrdir._path_for_remote_call(self._client)
1483
945
        for key in keys:
1485
947
                raise ValueError(
1486
948
                    "key %r not a plain string" % (key,))
1487
949
        verb = 'Repository.get_parent_map'
1488
 
        args = (path, 'include-missing:') + tuple(keys)
 
950
        args = (path,) + tuple(keys)
1489
951
        try:
1490
952
            response = self._call_with_body_bytes_expecting_body(
1491
953
                verb, args, body)
1501
963
            # To avoid having to disconnect repeatedly, we keep track of the
1502
964
            # fact the server doesn't understand remote methods added in 1.2.
1503
965
            medium._remember_remote_is_before((1, 2))
1504
 
            # Recurse just once and we should use the fallback code.
1505
 
            return self._get_parent_map_rpc(keys)
 
966
            return self.get_revision_graph(None)
1506
967
        response_tuple, response_handler = response
1507
968
        if response_tuple[0] not in ['ok']:
1508
969
            response_handler.cancel_read_body()
1519
980
                if len(d) > 1:
1520
981
                    revision_graph[d[0]] = d[1:]
1521
982
                else:
1522
 
                    # No parents:
1523
 
                    if d[0].startswith('missing:'):
1524
 
                        revid = d[0][8:]
1525
 
                        self._unstacked_provider.note_missing_key(revid)
1526
 
                    else:
1527
 
                        # no parents - so give the Graph result
1528
 
                        # (NULL_REVISION,).
1529
 
                        revision_graph[d[0]] = (NULL_REVISION,)
 
983
                    # No parents - so give the Graph result (NULL_REVISION,).
 
984
                    revision_graph[d[0]] = (NULL_REVISION,)
1530
985
            return revision_graph
1531
986
 
1532
987
    @needs_read_lock
1535
990
        return self._real_repository.get_signature_text(revision_id)
1536
991
 
1537
992
    @needs_read_lock
1538
 
    def _get_inventory_xml(self, revision_id):
1539
 
        self._ensure_real()
1540
 
        return self._real_repository._get_inventory_xml(revision_id)
 
993
    @symbol_versioning.deprecated_method(symbol_versioning.one_three)
 
994
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
995
        self._ensure_real()
 
996
        return self._real_repository.get_revision_graph_with_ghosts(
 
997
            revision_ids=revision_ids)
 
998
 
 
999
    @needs_read_lock
 
1000
    def get_inventory_xml(self, revision_id):
 
1001
        self._ensure_real()
 
1002
        return self._real_repository.get_inventory_xml(revision_id)
 
1003
 
 
1004
    def deserialise_inventory(self, revision_id, xml):
 
1005
        self._ensure_real()
 
1006
        return self._real_repository.deserialise_inventory(revision_id, xml)
1541
1007
 
1542
1008
    def reconcile(self, other=None, thorough=False):
1543
1009
        self._ensure_real()
1544
1010
        return self._real_repository.reconcile(other=other, thorough=thorough)
1545
 
 
 
1011
        
1546
1012
    def all_revision_ids(self):
1547
1013
        self._ensure_real()
1548
1014
        return self._real_repository.all_revision_ids()
1549
 
 
1550
 
    @needs_read_lock
1551
 
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1552
 
        self._ensure_real()
1553
 
        return self._real_repository.get_deltas_for_revisions(revisions,
1554
 
            specific_fileids=specific_fileids)
1555
 
 
1556
 
    @needs_read_lock
1557
 
    def get_revision_delta(self, revision_id, specific_fileids=None):
1558
 
        self._ensure_real()
1559
 
        return self._real_repository.get_revision_delta(revision_id,
1560
 
            specific_fileids=specific_fileids)
 
1015
    
 
1016
    @needs_read_lock
 
1017
    def get_deltas_for_revisions(self, revisions):
 
1018
        self._ensure_real()
 
1019
        return self._real_repository.get_deltas_for_revisions(revisions)
 
1020
 
 
1021
    @needs_read_lock
 
1022
    def get_revision_delta(self, revision_id):
 
1023
        self._ensure_real()
 
1024
        return self._real_repository.get_revision_delta(revision_id)
1561
1025
 
1562
1026
    @needs_read_lock
1563
1027
    def revision_trees(self, revision_ids):
1570
1034
        return self._real_repository.get_revision_reconcile(revision_id)
1571
1035
 
1572
1036
    @needs_read_lock
1573
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1037
    def check(self, revision_ids=None):
1574
1038
        self._ensure_real()
1575
 
        return self._real_repository.check(revision_ids=revision_ids,
1576
 
            callback_refs=callback_refs, check_repo=check_repo)
 
1039
        return self._real_repository.check(revision_ids=revision_ids)
1577
1040
 
1578
1041
    def copy_content_into(self, destination, revision_id=None):
1579
1042
        self._ensure_real()
1619
1082
        return self._real_repository.inventories
1620
1083
 
1621
1084
    @needs_write_lock
1622
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1085
    def pack(self):
1623
1086
        """Compress the data within the repository.
1624
1087
 
1625
1088
        This is not currently implemented within the smart server.
1626
1089
        """
1627
1090
        self._ensure_real()
1628
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1091
        return self._real_repository.pack()
1629
1092
 
1630
1093
    @property
1631
1094
    def revisions(self):
1640
1103
        return self._real_repository.revisions
1641
1104
 
1642
1105
    def set_make_working_trees(self, new_value):
1643
 
        if new_value:
1644
 
            new_value_str = "True"
1645
 
        else:
1646
 
            new_value_str = "False"
1647
 
        path = self.bzrdir._path_for_remote_call(self._client)
1648
 
        try:
1649
 
            response = self._call(
1650
 
                'Repository.set_make_working_trees', path, new_value_str)
1651
 
        except errors.UnknownSmartMethod:
1652
 
            self._ensure_real()
1653
 
            self._real_repository.set_make_working_trees(new_value)
1654
 
        else:
1655
 
            if response[0] != 'ok':
1656
 
                raise errors.UnexpectedSmartServerResponse(response)
 
1106
        self._ensure_real()
 
1107
        self._real_repository.set_make_working_trees(new_value)
1657
1108
 
1658
1109
    @property
1659
1110
    def signatures(self):
1686
1137
        return self._real_repository.get_revisions(revision_ids)
1687
1138
 
1688
1139
    def supports_rich_root(self):
1689
 
        return self._format.rich_root_data
 
1140
        self._ensure_real()
 
1141
        return self._real_repository.supports_rich_root()
1690
1142
 
1691
1143
    def iter_reverse_revision_history(self, revision_id):
1692
1144
        self._ensure_real()
1694
1146
 
1695
1147
    @property
1696
1148
    def _serializer(self):
1697
 
        return self._format._serializer
 
1149
        self._ensure_real()
 
1150
        return self._real_repository._serializer
1698
1151
 
1699
1152
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1700
1153
        self._ensure_real()
1719
1172
        self._ensure_real()
1720
1173
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
1174
 
1722
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
1175
    def _find_inconsistent_revision_parents(self):
1723
1176
        self._ensure_real()
1724
 
        return self._real_repository._find_inconsistent_revision_parents(
1725
 
            revisions_iterator)
 
1177
        return self._real_repository._find_inconsistent_revision_parents()
1726
1178
 
1727
1179
    def _check_for_inconsistent_revision_parents(self):
1728
1180
        self._ensure_real()
1734
1186
            providers.insert(0, other)
1735
1187
        providers.extend(r._make_parents_provider() for r in
1736
1188
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
1189
        return graph._StackedParentsProvider(providers)
1738
1190
 
1739
1191
    def _serialise_search_recipe(self, recipe):
1740
1192
        """Serialise a graph search recipe.
1742
1194
        :param recipe: A search recipe (start, stop, count).
1743
1195
        :return: Serialised bytes.
1744
1196
        """
1745
 
        start_keys = ' '.join(recipe[1])
1746
 
        stop_keys = ' '.join(recipe[2])
1747
 
        count = str(recipe[3])
 
1197
        start_keys = ' '.join(recipe[0])
 
1198
        stop_keys = ' '.join(recipe[1])
 
1199
        count = str(recipe[2])
1748
1200
        return '\n'.join((start_keys, stop_keys, count))
1749
1201
 
1750
 
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
1757
 
        return '\n'.join(parts)
1758
 
 
1759
1202
    def autopack(self):
1760
1203
        path = self.bzrdir._path_for_remote_call(self._client)
1761
1204
        try:
1764
1207
            self._ensure_real()
1765
1208
            self._real_repository._pack_collection.autopack()
1766
1209
            return
1767
 
        self.refresh_data()
 
1210
        if self._real_repository is not None:
 
1211
            # Reset the real repository's cache of pack names.
 
1212
            # XXX: At some point we may be able to skip this and just rely on
 
1213
            # the automatic retry logic to do the right thing, but for now we
 
1214
            # err on the side of being correct rather than being optimal.
 
1215
            self._real_repository._pack_collection.reload_pack_names()
1768
1216
        if response[0] != 'ok':
1769
1217
            raise errors.UnexpectedSmartServerResponse(response)
1770
1218
 
1771
1219
 
1772
 
class RemoteStreamSink(repository.StreamSink):
1773
 
 
1774
 
    def _insert_real(self, stream, src_format, resume_tokens):
1775
 
        self.target_repo._ensure_real()
1776
 
        sink = self.target_repo._real_repository._get_sink()
1777
 
        result = sink.insert_stream(stream, src_format, resume_tokens)
1778
 
        if not result:
1779
 
            self.target_repo.autopack()
1780
 
        return result
1781
 
 
1782
 
    def insert_stream(self, stream, src_format, resume_tokens):
1783
 
        target = self.target_repo
1784
 
        target._unstacked_provider.missing_keys.clear()
1785
 
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1786
 
        if target._lock_token:
1787
 
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1788
 
            lock_args = (target._lock_token or '',)
1789
 
        else:
1790
 
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
1791
 
            lock_args = ()
1792
 
        client = target._client
1793
 
        medium = client._medium
1794
 
        path = target.bzrdir._path_for_remote_call(client)
1795
 
        # Probe for the verb to use with an empty stream before sending the
1796
 
        # real stream to it.  We do this both to avoid the risk of sending a
1797
 
        # large request that is then rejected, and because we don't want to
1798
 
        # implement a way to buffer, rewind, or restart the stream.
1799
 
        found_verb = False
1800
 
        for verb, required_version in candidate_calls:
1801
 
            if medium._is_remote_before(required_version):
1802
 
                continue
1803
 
            if resume_tokens:
1804
 
                # We've already done the probing (and set _is_remote_before) on
1805
 
                # a previous insert.
1806
 
                found_verb = True
1807
 
                break
1808
 
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1809
 
            try:
1810
 
                response = client.call_with_body_stream(
1811
 
                    (verb, path, '') + lock_args, byte_stream)
1812
 
            except errors.UnknownSmartMethod:
1813
 
                medium._remember_remote_is_before(required_version)
1814
 
            else:
1815
 
                found_verb = True
1816
 
                break
1817
 
        if not found_verb:
1818
 
            # Have to use VFS.
1819
 
            return self._insert_real(stream, src_format, resume_tokens)
1820
 
        self._last_inv_record = None
1821
 
        self._last_substream = None
1822
 
        if required_version < (1, 19):
1823
 
            # Remote side doesn't support inventory deltas.  Wrap the stream to
1824
 
            # make sure we don't send any.  If the stream contains inventory
1825
 
            # deltas we'll interrupt the smart insert_stream request and
1826
 
            # fallback to VFS.
1827
 
            stream = self._stop_stream_if_inventory_delta(stream)
1828
 
        byte_stream = smart_repo._stream_to_byte_stream(
1829
 
            stream, src_format)
1830
 
        resume_tokens = ' '.join(resume_tokens)
1831
 
        response = client.call_with_body_stream(
1832
 
            (verb, path, resume_tokens) + lock_args, byte_stream)
1833
 
        if response[0][0] not in ('ok', 'missing-basis'):
1834
 
            raise errors.UnexpectedSmartServerResponse(response)
1835
 
        if self._last_substream is not None:
1836
 
            # The stream included an inventory-delta record, but the remote
1837
 
            # side isn't new enough to support them.  So we need to send the
1838
 
            # rest of the stream via VFS.
1839
 
            self.target_repo.refresh_data()
1840
 
            return self._resume_stream_with_vfs(response, src_format)
1841
 
        if response[0][0] == 'missing-basis':
1842
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1843
 
            resume_tokens = tokens
1844
 
            return resume_tokens, set(missing_keys)
1845
 
        else:
1846
 
            self.target_repo.refresh_data()
1847
 
            return [], set()
1848
 
 
1849
 
    def _resume_stream_with_vfs(self, response, src_format):
1850
 
        """Resume sending a stream via VFS, first resending the record and
1851
 
        substream that couldn't be sent via an insert_stream verb.
1852
 
        """
1853
 
        if response[0][0] == 'missing-basis':
1854
 
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1855
 
            # Ignore missing_keys, we haven't finished inserting yet
1856
 
        else:
1857
 
            tokens = []
1858
 
        def resume_substream():
1859
 
            # Yield the substream that was interrupted.
1860
 
            for record in self._last_substream:
1861
 
                yield record
1862
 
            self._last_substream = None
1863
 
        def resume_stream():
1864
 
            # Finish sending the interrupted substream
1865
 
            yield ('inventory-deltas', resume_substream())
1866
 
            # Then simply continue sending the rest of the stream.
1867
 
            for substream_kind, substream in self._last_stream:
1868
 
                yield substream_kind, substream
1869
 
        return self._insert_real(resume_stream(), src_format, tokens)
1870
 
 
1871
 
    def _stop_stream_if_inventory_delta(self, stream):
1872
 
        """Normally this just lets the original stream pass-through unchanged.
1873
 
 
1874
 
        However if any 'inventory-deltas' substream occurs it will stop
1875
 
        streaming, and store the interrupted substream and stream in
1876
 
        self._last_substream and self._last_stream so that the stream can be
1877
 
        resumed by _resume_stream_with_vfs.
1878
 
        """
1879
 
                    
1880
 
        stream_iter = iter(stream)
1881
 
        for substream_kind, substream in stream_iter:
1882
 
            if substream_kind == 'inventory-deltas':
1883
 
                self._last_substream = substream
1884
 
                self._last_stream = stream_iter
1885
 
                return
1886
 
            else:
1887
 
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
1891
 
    """Stream data from a remote server."""
1892
 
 
1893
 
    def get_stream(self, search):
1894
 
        if (self.from_repository._fallback_repositories and
1895
 
            self.to_format._fetch_order == 'topological'):
1896
 
            return self._real_stream(self.from_repository, search)
1897
 
        sources = []
1898
 
        seen = set()
1899
 
        repos = [self.from_repository]
1900
 
        while repos:
1901
 
            repo = repos.pop(0)
1902
 
            if repo in seen:
1903
 
                continue
1904
 
            seen.add(repo)
1905
 
            repos.extend(repo._fallback_repositories)
1906
 
            sources.append(repo)
1907
 
        return self.missing_parents_chain(search, sources)
1908
 
 
1909
 
    def get_stream_for_missing_keys(self, missing_keys):
1910
 
        self.from_repository._ensure_real()
1911
 
        real_repo = self.from_repository._real_repository
1912
 
        real_source = real_repo._get_source(self.to_format)
1913
 
        return real_source.get_stream_for_missing_keys(missing_keys)
1914
 
 
1915
 
    def _real_stream(self, repo, search):
1916
 
        """Get a stream for search from repo.
1917
 
        
1918
 
        This never called RemoteStreamSource.get_stream, and is a heler
1919
 
        for RemoteStreamSource._get_stream to allow getting a stream 
1920
 
        reliably whether fallback back because of old servers or trying
1921
 
        to stream from a non-RemoteRepository (which the stacked support
1922
 
        code will do).
1923
 
        """
1924
 
        source = repo._get_source(self.to_format)
1925
 
        if isinstance(source, RemoteStreamSource):
1926
 
            repo._ensure_real()
1927
 
            source = repo._real_repository._get_source(self.to_format)
1928
 
        return source.get_stream(search)
1929
 
 
1930
 
    def _get_stream(self, repo, search):
1931
 
        """Core worker to get a stream from repo for search.
1932
 
 
1933
 
        This is used by both get_stream and the stacking support logic. It
1934
 
        deliberately gets a stream for repo which does not need to be
1935
 
        self.from_repository. In the event that repo is not Remote, or
1936
 
        cannot do a smart stream, a fallback is made to the generic
1937
 
        repository._get_stream() interface, via self._real_stream.
1938
 
 
1939
 
        In the event of stacking, streams from _get_stream will not
1940
 
        contain all the data for search - this is normal (see get_stream).
1941
 
 
1942
 
        :param repo: A repository.
1943
 
        :param search: A search.
1944
 
        """
1945
 
        # Fallbacks may be non-smart
1946
 
        if not isinstance(repo, RemoteRepository):
1947
 
            return self._real_stream(repo, search)
1948
 
        client = repo._client
1949
 
        medium = client._medium
1950
 
        path = repo.bzrdir._path_for_remote_call(client)
1951
 
        search_bytes = repo._serialise_search_result(search)
1952
 
        args = (path, self.to_format.network_name())
1953
 
        candidate_verbs = [
1954
 
            ('Repository.get_stream_1.19', (1, 19)),
1955
 
            ('Repository.get_stream', (1, 13))]
1956
 
        found_verb = False
1957
 
        for verb, version in candidate_verbs:
1958
 
            if medium._is_remote_before(version):
1959
 
                continue
1960
 
            try:
1961
 
                response = repo._call_with_body_bytes_expecting_body(
1962
 
                    verb, args, search_bytes)
1963
 
            except errors.UnknownSmartMethod:
1964
 
                medium._remember_remote_is_before(version)
1965
 
            else:
1966
 
                response_tuple, response_handler = response
1967
 
                found_verb = True
1968
 
                break
1969
 
        if not found_verb:
1970
 
            return self._real_stream(repo, search)
1971
 
        if response_tuple[0] != 'ok':
1972
 
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
 
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1975
 
        if src_format.network_name() != repo._format.network_name():
1976
 
            raise AssertionError(
1977
 
                "Mismatched RemoteRepository and stream src %r, %r" % (
1978
 
                src_format.network_name(), repo._format.network_name()))
1979
 
        return stream
1980
 
 
1981
 
    def missing_parents_chain(self, search, sources):
1982
 
        """Chain multiple streams together to handle stacking.
1983
 
 
1984
 
        :param search: The overall search to satisfy with streams.
1985
 
        :param sources: A list of Repository objects to query.
1986
 
        """
1987
 
        self.from_serialiser = self.from_repository._format._serializer
1988
 
        self.seen_revs = set()
1989
 
        self.referenced_revs = set()
1990
 
        # If there are heads in the search, or the key count is > 0, we are not
1991
 
        # done.
1992
 
        while not search.is_empty() and len(sources) > 1:
1993
 
            source = sources.pop(0)
1994
 
            stream = self._get_stream(source, search)
1995
 
            for kind, substream in stream:
1996
 
                if kind != 'revisions':
1997
 
                    yield kind, substream
1998
 
                else:
1999
 
                    yield kind, self.missing_parents_rev_handler(substream)
2000
 
            search = search.refine(self.seen_revs, self.referenced_revs)
2001
 
            self.seen_revs = set()
2002
 
            self.referenced_revs = set()
2003
 
        if not search.is_empty():
2004
 
            for kind, stream in self._get_stream(sources[0], search):
2005
 
                yield kind, stream
2006
 
 
2007
 
    def missing_parents_rev_handler(self, substream):
2008
 
        for content in substream:
2009
 
            revision_bytes = content.get_bytes_as('fulltext')
2010
 
            revision = self.from_serialiser.read_revision_from_string(
2011
 
                revision_bytes)
2012
 
            self.seen_revs.add(content.key[-1])
2013
 
            self.referenced_revs.update(revision.parent_ids)
2014
 
            yield content
2015
 
 
2016
 
 
2017
1220
class RemoteBranchLockableFiles(LockableFiles):
2018
1221
    """A 'LockableFiles' implementation that talks to a smart server.
2019
 
 
 
1222
    
2020
1223
    This is not a public interface class.
2021
1224
    """
2022
1225
 
2036
1239
 
2037
1240
class RemoteBranchFormat(branch.BranchFormat):
2038
1241
 
2039
 
    def __init__(self, network_name=None):
 
1242
    def __init__(self):
2040
1243
        super(RemoteBranchFormat, self).__init__()
2041
1244
        self._matchingbzrdir = RemoteBzrDirFormat()
2042
1245
        self._matchingbzrdir.set_branch_format(self)
2043
 
        self._custom_format = None
2044
 
        self._network_name = network_name
2045
1246
 
2046
1247
    def __eq__(self, other):
2047
 
        return (isinstance(other, RemoteBranchFormat) and
 
1248
        return (isinstance(other, RemoteBranchFormat) and 
2048
1249
            self.__dict__ == other.__dict__)
2049
1250
 
2050
 
    def _ensure_real(self):
2051
 
        if self._custom_format is None:
2052
 
            self._custom_format = branch.network_format_registry.get(
2053
 
                self._network_name)
2054
 
 
2055
1251
    def get_format_description(self):
2056
 
        self._ensure_real()
2057
 
        return 'Remote: ' + self._custom_format.get_format_description()
2058
 
 
2059
 
    def network_name(self):
2060
 
        return self._network_name
2061
 
 
2062
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2063
 
        return a_bzrdir.open_branch(name=name, 
2064
 
            ignore_fallbacks=ignore_fallbacks)
2065
 
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
2067
 
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
 
        # method is not available on the server.
2069
 
        # self._custom_format is always set - the start of initialize ensures
2070
 
        # that.
2071
 
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
 
            a_bzrdir._ensure_real()
2073
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
2075
 
        else:
2076
 
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
2078
 
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
 
            not isinstance(result, RemoteBranch)):
2080
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
 
                                  name=name)
2082
 
        return result
2083
 
 
2084
 
    def initialize(self, a_bzrdir, name=None):
2085
 
        # 1) get the network name to use.
2086
 
        if self._custom_format:
2087
 
            network_name = self._custom_format.network_name()
2088
 
        else:
2089
 
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
2091
 
            reference_format = reference_bzrdir_format.get_branch_format()
2092
 
            self._custom_format = reference_format
2093
 
            network_name = reference_format.network_name()
2094
 
        # Being asked to create on a non RemoteBzrDir:
2095
 
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
2097
 
        medium = a_bzrdir._client._medium
2098
 
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
2100
 
        # Creating on a remote bzr dir.
2101
 
        # 2) try direct creation via RPC
2102
 
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2103
 
        if name is not None:
2104
 
            # XXX JRV20100304: Support creating colocated branches
2105
 
            raise errors.NoColocatedBranchSupport(self)
2106
 
        verb = 'BzrDir.create_branch'
2107
 
        try:
2108
 
            response = a_bzrdir._call(verb, path, network_name)
2109
 
        except errors.UnknownSmartMethod:
2110
 
            # Fallback - use vfs methods
2111
 
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
2113
 
        if response[0] != 'ok':
2114
 
            raise errors.UnexpectedSmartServerResponse(response)
2115
 
        # Turn the response into a RemoteRepository object.
2116
 
        format = RemoteBranchFormat(network_name=response[1])
2117
 
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
2120
 
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
 
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
 
            format=format, setup_stacking=False, name=name)
2127
 
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
 
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
 
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2130
 
        remote_branch._last_revision_info_cache = 0, NULL_REVISION
2131
 
        return remote_branch
2132
 
 
2133
 
    def make_tags(self, branch):
2134
 
        self._ensure_real()
2135
 
        return self._custom_format.make_tags(branch)
 
1252
        return 'Remote BZR Branch'
 
1253
 
 
1254
    def get_format_string(self):
 
1255
        return 'Remote BZR Branch'
 
1256
 
 
1257
    def open(self, a_bzrdir):
 
1258
        return a_bzrdir.open_branch()
 
1259
 
 
1260
    def initialize(self, a_bzrdir):
 
1261
        return a_bzrdir.create_branch()
2136
1262
 
2137
1263
    def supports_tags(self):
2138
1264
        # Remote branches might support tags, but we won't know until we
2139
1265
        # access the real remote branch.
2140
 
        self._ensure_real()
2141
 
        return self._custom_format.supports_tags()
2142
 
 
2143
 
    def supports_stacking(self):
2144
 
        self._ensure_real()
2145
 
        return self._custom_format.supports_stacking()
2146
 
 
2147
 
    def supports_set_append_revisions_only(self):
2148
 
        self._ensure_real()
2149
 
        return self._custom_format.supports_set_append_revisions_only()
2150
 
 
2151
 
 
2152
 
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
1266
        return True
 
1267
 
 
1268
 
 
1269
class RemoteBranch(branch.Branch, _RpcHelper):
2153
1270
    """Branch stored on a server accessed by HPSS RPC.
2154
1271
 
2155
1272
    At the moment most operations are mapped down to simple file operations.
2156
1273
    """
2157
1274
 
2158
1275
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2159
 
        _client=None, format=None, setup_stacking=True, name=None):
 
1276
        _client=None):
2160
1277
        """Create a RemoteBranch instance.
2161
1278
 
2162
1279
        :param real_branch: An optional local implementation of the branch
2163
1280
            format, usually accessing the data via the VFS.
2164
1281
        :param _client: Private parameter for testing.
2165
 
        :param format: A RemoteBranchFormat object, None to create one
2166
 
            automatically. If supplied it should have a network_name already
2167
 
            supplied.
2168
 
        :param setup_stacking: If True make an RPC call to determine the
2169
 
            stacked (or not) status of the branch. If False assume the branch
2170
 
            is not stacked.
2171
 
        :param name: Colocated branch name
2172
1282
        """
2173
1283
        # We intentionally don't call the parent class's __init__, because it
2174
1284
        # will try to assign to self.tags, which is a property in this subclass.
2175
1285
        # And the parent's __init__ doesn't do much anyway.
 
1286
        self._revision_id_to_revno_cache = None
 
1287
        self._revision_history_cache = None
 
1288
        self._last_revision_info_cache = None
2176
1289
        self.bzrdir = remote_bzrdir
2177
1290
        if _client is not None:
2178
1291
            self._client = _client
2191
1304
            self._real_branch.repository = self.repository
2192
1305
        else:
2193
1306
            self._real_branch = None
2194
 
        # Fill out expected attributes of branch for bzrlib API users.
2195
 
        self._clear_cached_state()
2196
 
        # TODO: deprecate self.base in favor of user_url
2197
 
        self.base = self.bzrdir.user_url
2198
 
        self._name = name
 
1307
        # Fill out expected attributes of branch for bzrlib api users.
 
1308
        self._format = RemoteBranchFormat()
 
1309
        self.base = self.bzrdir.root_transport.base
2199
1310
        self._control_files = None
2200
1311
        self._lock_mode = None
2201
1312
        self._lock_token = None
2202
1313
        self._repo_lock_token = None
2203
1314
        self._lock_count = 0
2204
1315
        self._leave_lock = False
2205
 
        # Setup a format: note that we cannot call _ensure_real until all the
2206
 
        # attributes above are set: This code cannot be moved higher up in this
2207
 
        # function.
2208
 
        if format is None:
2209
 
            self._format = RemoteBranchFormat()
2210
 
            if real_branch is not None:
2211
 
                self._format._network_name = \
2212
 
                    self._real_branch._format.network_name()
2213
 
        else:
2214
 
            self._format = format
2215
 
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
2216
 
        # branch.open_branch method.
2217
 
        self._real_ignore_fallbacks = not setup_stacking
2218
 
        if not self._format._network_name:
2219
 
            # Did not get from open_branchV2 - old server.
2220
 
            self._ensure_real()
2221
 
            self._format._network_name = \
2222
 
                self._real_branch._format.network_name()
2223
 
        self.tags = self._format.make_tags(self)
2224
1316
        # The base class init is not called, so we duplicate this:
2225
1317
        hooks = branch.Branch.hooks['open']
2226
1318
        for hook in hooks:
2227
1319
            hook(self)
2228
 
        self._is_stacked = False
2229
 
        if setup_stacking:
2230
 
            self._setup_stacking()
 
1320
        self._setup_stacking()
2231
1321
 
2232
1322
    def _setup_stacking(self):
2233
1323
        # configure stacking into the remote repository, by reading it from
2237
1327
        except (errors.NotStacked, errors.UnstackableBranchFormat,
2238
1328
            errors.UnstackableRepositoryFormat), e:
2239
1329
            return
2240
 
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
2242
 
 
2243
 
    def _get_config(self):
2244
 
        return RemoteBranchConfig(self)
 
1330
        # it's relative to this branch...
 
1331
        fallback_url = urlutils.join(self.base, fallback_url)
 
1332
        transports = [self.bzrdir.root_transport]
 
1333
        if self._real_branch is not None:
 
1334
            transports.append(self._real_branch._transport)
 
1335
        stacked_on = branch.Branch.open(fallback_url,
 
1336
                                        possible_transports=transports)
 
1337
        self.repository.add_fallback_repository(stacked_on.repository)
2245
1338
 
2246
1339
    def _get_real_transport(self):
2247
1340
        # if we try vfs access, return the real branch's vfs transport
2265
1358
                raise AssertionError('smart server vfs must be enabled '
2266
1359
                    'to use vfs implementation')
2267
1360
            self.bzrdir._ensure_real()
2268
 
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2269
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
1361
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2270
1362
            if self.repository._real_repository is None:
2271
1363
                # Give the remote repository the matching real repo.
2272
1364
                real_repo = self._real_branch.repository
2301
1393
        too, in fact doing so might harm performance.
2302
1394
        """
2303
1395
        super(RemoteBranch, self)._clear_cached_state()
2304
 
 
 
1396
        
2305
1397
    @property
2306
1398
    def control_files(self):
2307
1399
        # Defer actually creating RemoteBranchLockableFiles until its needed,
2346
1438
            raise errors.UnexpectedSmartServerResponse(response)
2347
1439
        return response[1]
2348
1440
 
2349
 
    def set_stacked_on_url(self, url):
2350
 
        branch.Branch.set_stacked_on_url(self, url)
2351
 
        if not url:
2352
 
            self._is_stacked = False
2353
 
        else:
2354
 
            self._is_stacked = True
2355
 
        
2356
 
    def _vfs_get_tags_bytes(self):
2357
 
        self._ensure_real()
2358
 
        return self._real_branch._get_tags_bytes()
2359
 
 
2360
 
    def _get_tags_bytes(self):
2361
 
        medium = self._client._medium
2362
 
        if medium._is_remote_before((1, 13)):
2363
 
            return self._vfs_get_tags_bytes()
2364
 
        try:
2365
 
            response = self._call('Branch.get_tags_bytes', self._remote_path())
2366
 
        except errors.UnknownSmartMethod:
2367
 
            medium._remember_remote_is_before((1, 13))
2368
 
            return self._vfs_get_tags_bytes()
2369
 
        return response[0]
2370
 
 
2371
 
    def _vfs_set_tags_bytes(self, bytes):
2372
 
        self._ensure_real()
2373
 
        return self._real_branch._set_tags_bytes(bytes)
2374
 
 
2375
 
    def _set_tags_bytes(self, bytes):
2376
 
        medium = self._client._medium
2377
 
        if medium._is_remote_before((1, 18)):
2378
 
            self._vfs_set_tags_bytes(bytes)
2379
 
            return
2380
 
        try:
2381
 
            args = (
2382
 
                self._remote_path(), self._lock_token, self._repo_lock_token)
2383
 
            response = self._call_with_body_bytes(
2384
 
                'Branch.set_tags_bytes', args, bytes)
2385
 
        except errors.UnknownSmartMethod:
2386
 
            medium._remember_remote_is_before((1, 18))
2387
 
            self._vfs_set_tags_bytes(bytes)
2388
 
 
2389
1441
    def lock_read(self):
2390
1442
        self.repository.lock_read()
2391
1443
        if not self._lock_mode:
2392
 
            self._note_lock('r')
2393
1444
            self._lock_mode = 'r'
2394
1445
            self._lock_count = 1
2395
1446
            if self._real_branch is not None:
2412
1463
            raise errors.UnexpectedSmartServerResponse(response)
2413
1464
        ok, branch_token, repo_token = response
2414
1465
        return branch_token, repo_token
2415
 
 
 
1466
            
2416
1467
    def lock_write(self, token=None):
2417
1468
        if not self._lock_mode:
2418
 
            self._note_lock('w')
2419
1469
            # Lock the branch and repo in one remote call.
2420
1470
            remote_tokens = self._remote_lock_write(token)
2421
1471
            self._lock_token, self._repo_lock_token = remote_tokens
2456
1506
            return
2457
1507
        raise errors.UnexpectedSmartServerResponse(response)
2458
1508
 
2459
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2460
1509
    def unlock(self):
2461
1510
        try:
2462
1511
            self._lock_count -= 1
2475
1524
                    self._real_branch.unlock()
2476
1525
                if mode != 'w':
2477
1526
                    # Only write-locked branched need to make a remote method
2478
 
                    # call to perform the unlock.
 
1527
                    # call to perfom the unlock.
2479
1528
                    return
2480
1529
                if not self._lock_token:
2481
1530
                    raise AssertionError('Locked, but no token!')
2502
1551
            raise NotImplementedError(self.dont_leave_lock_in_place)
2503
1552
        self._leave_lock = False
2504
1553
 
2505
 
    @needs_read_lock
2506
 
    def get_rev_id(self, revno, history=None):
2507
 
        if revno == 0:
2508
 
            return _mod_revision.NULL_REVISION
2509
 
        last_revision_info = self.last_revision_info()
2510
 
        ok, result = self.repository.get_rev_id_for_revno(
2511
 
            revno, last_revision_info)
2512
 
        if ok:
2513
 
            return result
2514
 
        missing_parent = result[1]
2515
 
        # Either the revision named by the server is missing, or its parent
2516
 
        # is.  Call get_parent_map to determine which, so that we report a
2517
 
        # useful error.
2518
 
        parent_map = self.repository.get_parent_map([missing_parent])
2519
 
        if missing_parent in parent_map:
2520
 
            missing_parent = parent_map[missing_parent]
2521
 
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
 
 
2523
1554
    def _last_revision_info(self):
2524
1555
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
1556
        if response[0] != 'ok':
2530
1561
 
2531
1562
    def _gen_revision_history(self):
2532
1563
        """See Branch._gen_revision_history()."""
2533
 
        if self._is_stacked:
2534
 
            self._ensure_real()
2535
 
            return self._real_branch._gen_revision_history()
2536
1564
        response_tuple, response_handler = self._call_expecting_body(
2537
1565
            'Branch.revision_history', self._remote_path())
2538
1566
        if response_tuple[0] != 'ok':
2547
1575
 
2548
1576
    def _set_last_revision_descendant(self, revision_id, other_branch,
2549
1577
            allow_diverged=False, allow_overwrite_descendant=False):
2550
 
        # This performs additional work to meet the hook contract; while its
2551
 
        # undesirable, we have to synthesise the revno to call the hook, and
2552
 
        # not calling the hook is worse as it means changes can't be prevented.
2553
 
        # Having calculated this though, we can't just call into
2554
 
        # set_last_revision_info as a simple call, because there is a set_rh
2555
 
        # hook that some folk may still be using.
2556
 
        old_revno, old_revid = self.last_revision_info()
2557
 
        history = self._lefthand_history(revision_id)
2558
 
        self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2559
1578
        err_context = {'other_branch': other_branch}
2560
1579
        response = self._call('Branch.set_last_revision_ex',
2561
1580
            self._remote_path(), self._lock_token, self._repo_lock_token,
2566
1585
            raise errors.UnexpectedSmartServerResponse(response)
2567
1586
        new_revno, new_revision_id = response[1:]
2568
1587
        self._last_revision_info_cache = new_revno, new_revision_id
2569
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2570
1588
        if self._real_branch is not None:
2571
1589
            cache = new_revno, new_revision_id
2572
1590
            self._real_branch._last_revision_info_cache = cache
2573
1591
 
2574
1592
    def _set_last_revision(self, revision_id):
2575
 
        old_revno, old_revid = self.last_revision_info()
2576
 
        # This performs additional work to meet the hook contract; while its
2577
 
        # undesirable, we have to synthesise the revno to call the hook, and
2578
 
        # not calling the hook is worse as it means changes can't be prevented.
2579
 
        # Having calculated this though, we can't just call into
2580
 
        # set_last_revision_info as a simple call, because there is a set_rh
2581
 
        # hook that some folk may still be using.
2582
 
        history = self._lefthand_history(revision_id)
2583
 
        self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2584
1593
        self._clear_cached_state()
2585
1594
        response = self._call('Branch.set_last_revision',
2586
1595
            self._remote_path(), self._lock_token, self._repo_lock_token,
2587
1596
            revision_id)
2588
1597
        if response != ('ok',):
2589
1598
            raise errors.UnexpectedSmartServerResponse(response)
2590
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
1599
 
2592
1600
    @needs_write_lock
2593
1601
    def set_revision_history(self, rev_history):
2599
1607
        else:
2600
1608
            rev_id = rev_history[-1]
2601
1609
        self._set_last_revision(rev_id)
2602
 
        for hook in branch.Branch.hooks['set_rh']:
2603
 
            hook(self, rev_history)
2604
1610
        self._cache_revision_history(rev_history)
2605
1611
 
2606
 
    def _get_parent_location(self):
2607
 
        medium = self._client._medium
2608
 
        if medium._is_remote_before((1, 13)):
2609
 
            return self._vfs_get_parent_location()
2610
 
        try:
2611
 
            response = self._call('Branch.get_parent', self._remote_path())
2612
 
        except errors.UnknownSmartMethod:
2613
 
            medium._remember_remote_is_before((1, 13))
2614
 
            return self._vfs_get_parent_location()
2615
 
        if len(response) != 1:
2616
 
            raise errors.UnexpectedSmartServerResponse(response)
2617
 
        parent_location = response[0]
2618
 
        if parent_location == '':
2619
 
            return None
2620
 
        return parent_location
2621
 
 
2622
 
    def _vfs_get_parent_location(self):
2623
 
        self._ensure_real()
2624
 
        return self._real_branch._get_parent_location()
2625
 
 
2626
 
    def _set_parent_location(self, url):
2627
 
        medium = self._client._medium
2628
 
        if medium._is_remote_before((1, 15)):
2629
 
            return self._vfs_set_parent_location(url)
2630
 
        try:
2631
 
            call_url = url or ''
2632
 
            if type(call_url) is not str:
2633
 
                raise AssertionError('url must be a str or None (%s)' % url)
2634
 
            response = self._call('Branch.set_parent_location',
2635
 
                self._remote_path(), self._lock_token, self._repo_lock_token,
2636
 
                call_url)
2637
 
        except errors.UnknownSmartMethod:
2638
 
            medium._remember_remote_is_before((1, 15))
2639
 
            return self._vfs_set_parent_location(url)
2640
 
        if response != ():
2641
 
            raise errors.UnexpectedSmartServerResponse(response)
2642
 
 
2643
 
    def _vfs_set_parent_location(self, url):
2644
 
        self._ensure_real()
2645
 
        return self._real_branch._set_parent_location(url)
 
1612
    def get_parent(self):
 
1613
        self._ensure_real()
 
1614
        return self._real_branch.get_parent()
 
1615
        
 
1616
    def set_parent(self, url):
 
1617
        self._ensure_real()
 
1618
        return self._real_branch.set_parent(url)
 
1619
        
 
1620
    def set_stacked_on_url(self, stacked_location):
 
1621
        """Set the URL this branch is stacked against.
 
1622
 
 
1623
        :raises UnstackableBranchFormat: If the branch does not support
 
1624
            stacking.
 
1625
        :raises UnstackableRepositoryFormat: If the repository does not support
 
1626
            stacking.
 
1627
        """
 
1628
        self._ensure_real()
 
1629
        return self._real_branch.set_stacked_on_url(stacked_location)
 
1630
 
 
1631
    def sprout(self, to_bzrdir, revision_id=None):
 
1632
        branch_format = to_bzrdir._format._branch_format
 
1633
        if (branch_format is None or
 
1634
            isinstance(branch_format, RemoteBranchFormat)):
 
1635
            # The to_bzrdir specifies RemoteBranchFormat (or no format, which
 
1636
            # implies the same thing), but RemoteBranches can't be created at
 
1637
            # arbitrary URLs.  So create a branch in the same format as
 
1638
            # _real_branch instead.
 
1639
            # XXX: if to_bzrdir is a RemoteBzrDir, this should perhaps do
 
1640
            # to_bzrdir.create_branch to create a RemoteBranch after all...
 
1641
            self._ensure_real()
 
1642
            result = self._real_branch._format.initialize(to_bzrdir)
 
1643
            self.copy_content_into(result, revision_id=revision_id)
 
1644
            result.set_parent(self.bzrdir.root_transport.base)
 
1645
        else:
 
1646
            result = branch.Branch.sprout(
 
1647
                self, to_bzrdir, revision_id=revision_id)
 
1648
        return result
2646
1649
 
2647
1650
    @needs_write_lock
2648
1651
    def pull(self, source, overwrite=False, stop_revision=None,
2670
1673
 
2671
1674
    @needs_write_lock
2672
1675
    def set_last_revision_info(self, revno, revision_id):
2673
 
        # XXX: These should be returned by the set_last_revision_info verb
2674
 
        old_revno, old_revid = self.last_revision_info()
2675
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
1676
        revision_id = ensure_null(revision_id)
2677
1677
        try:
2678
1678
            response = self._call('Branch.set_last_revision_info',
2687
1687
        if response == ('ok',):
2688
1688
            self._clear_cached_state()
2689
1689
            self._last_revision_info_cache = revno, revision_id
2690
 
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2691
1690
            # Update the _real_branch's cache too.
2692
1691
            if self._real_branch is not None:
2693
1692
                cache = self._last_revision_info_cache
2700
1699
                                  other_branch=None):
2701
1700
        medium = self._client._medium
2702
1701
        if not medium._is_remote_before((1, 6)):
2703
 
            # Use a smart method for 1.6 and above servers
2704
1702
            try:
2705
1703
                self._set_last_revision_descendant(revision_id, other_branch,
2706
1704
                    allow_diverged=True, allow_overwrite_descendant=True)
2708
1706
            except errors.UnknownSmartMethod:
2709
1707
                medium._remember_remote_is_before((1, 6))
2710
1708
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
2712
 
            last_rev=last_rev,other_branch=other_branch))
 
1709
        self._ensure_real()
 
1710
        self._real_branch.generate_revision_history(
 
1711
            revision_id, last_rev=last_rev, other_branch=other_branch)
 
1712
 
 
1713
    @property
 
1714
    def tags(self):
 
1715
        self._ensure_real()
 
1716
        return self._real_branch.tags
2713
1717
 
2714
1718
    def set_push_location(self, location):
2715
1719
        self._ensure_real()
2716
1720
        return self._real_branch.set_push_location(location)
2717
1721
 
2718
 
 
2719
 
class RemoteConfig(object):
2720
 
    """A Config that reads and writes from smart verbs.
2721
 
 
2722
 
    It is a low-level object that considers config data to be name/value pairs
2723
 
    that may be associated with a section. Assigning meaning to the these
2724
 
    values is done at higher levels like bzrlib.config.TreeConfig.
2725
 
    """
2726
 
 
2727
 
    def get_option(self, name, section=None, default=None):
2728
 
        """Return the value associated with a named option.
2729
 
 
2730
 
        :param name: The name of the value
2731
 
        :param section: The section the option is in (if any)
2732
 
        :param default: The value to return if the value is not set
2733
 
        :return: The value or default value
2734
 
        """
 
1722
    @needs_write_lock
 
1723
    def update_revisions(self, other, stop_revision=None, overwrite=False,
 
1724
                         graph=None):
 
1725
        """See Branch.update_revisions."""
 
1726
        other.lock_read()
2735
1727
        try:
2736
 
            configobj = self._get_configobj()
2737
 
            if section is None:
2738
 
                section_obj = configobj
 
1728
            if stop_revision is None:
 
1729
                stop_revision = other.last_revision()
 
1730
                if revision.is_null(stop_revision):
 
1731
                    # if there are no commits, we're done.
 
1732
                    return
 
1733
            self.fetch(other, stop_revision)
 
1734
 
 
1735
            if overwrite:
 
1736
                # Just unconditionally set the new revision.  We don't care if
 
1737
                # the branches have diverged.
 
1738
                self._set_last_revision(stop_revision)
2739
1739
            else:
2740
 
                try:
2741
 
                    section_obj = configobj[section]
2742
 
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
2745
 
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
2747
 
 
2748
 
    def _response_to_configobj(self, response):
2749
 
        if len(response[0]) and response[0][0] != 'ok':
2750
 
            raise errors.UnexpectedSmartServerResponse(response)
2751
 
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
2753
 
 
2754
 
 
2755
 
class RemoteBranchConfig(RemoteConfig):
2756
 
    """A RemoteConfig for Branches."""
2757
 
 
2758
 
    def __init__(self, branch):
2759
 
        self._branch = branch
2760
 
 
2761
 
    def _get_configobj(self):
2762
 
        path = self._branch._remote_path()
2763
 
        response = self._branch._client.call_expecting_body(
2764
 
            'Branch.get_config_file', path)
2765
 
        return self._response_to_configobj(response)
2766
 
 
2767
 
    def set_option(self, value, name, section=None):
2768
 
        """Set the value associated with a named option.
2769
 
 
2770
 
        :param value: The value to set
2771
 
        :param name: The name of the value to set
2772
 
        :param section: The section the option is in (if any)
2773
 
        """
2774
 
        medium = self._branch._client._medium
2775
 
        if medium._is_remote_before((1, 14)):
2776
 
            return self._vfs_set_option(value, name, section)
2777
 
        try:
2778
 
            path = self._branch._remote_path()
2779
 
            response = self._branch._client.call('Branch.set_config_option',
2780
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
 
                value.encode('utf8'), name, section or '')
2782
 
        except errors.UnknownSmartMethod:
2783
 
            medium._remember_remote_is_before((1, 14))
2784
 
            return self._vfs_set_option(value, name, section)
2785
 
        if response != ():
2786
 
            raise errors.UnexpectedSmartServerResponse(response)
2787
 
 
2788
 
    def _real_object(self):
2789
 
        self._branch._ensure_real()
2790
 
        return self._branch._real_branch
2791
 
 
2792
 
    def _vfs_set_option(self, value, name, section=None):
2793
 
        return self._real_object()._get_config().set_option(
2794
 
            value, name, section)
2795
 
 
2796
 
 
2797
 
class RemoteBzrDirConfig(RemoteConfig):
2798
 
    """A RemoteConfig for BzrDirs."""
2799
 
 
2800
 
    def __init__(self, bzrdir):
2801
 
        self._bzrdir = bzrdir
2802
 
 
2803
 
    def _get_configobj(self):
2804
 
        medium = self._bzrdir._client._medium
2805
 
        verb = 'BzrDir.get_config_file'
2806
 
        if medium._is_remote_before((1, 15)):
2807
 
            raise errors.UnknownSmartMethod(verb)
2808
 
        path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2809
 
        response = self._bzrdir._call_expecting_body(
2810
 
            verb, path)
2811
 
        return self._response_to_configobj(response)
2812
 
 
2813
 
    def _vfs_get_option(self, name, section, default):
2814
 
        return self._real_object()._get_config().get_option(
2815
 
            name, section, default)
2816
 
 
2817
 
    def set_option(self, value, name, section=None):
2818
 
        """Set the value associated with a named option.
2819
 
 
2820
 
        :param value: The value to set
2821
 
        :param name: The name of the value to set
2822
 
        :param section: The section the option is in (if any)
2823
 
        """
2824
 
        return self._real_object()._get_config().set_option(
2825
 
            value, name, section)
2826
 
 
2827
 
    def _real_object(self):
2828
 
        self._bzrdir._ensure_real()
2829
 
        return self._bzrdir._real_bzrdir
2830
 
 
 
1740
                medium = self._client._medium
 
1741
                if not medium._is_remote_before((1, 6)):
 
1742
                    try:
 
1743
                        self._set_last_revision_descendant(stop_revision, other)
 
1744
                        return
 
1745
                    except errors.UnknownSmartMethod:
 
1746
                        medium._remember_remote_is_before((1, 6))
 
1747
                # Fallback for pre-1.6 servers: check for divergence
 
1748
                # client-side, then do _set_last_revision.
 
1749
                last_rev = revision.ensure_null(self.last_revision())
 
1750
                if graph is None:
 
1751
                    graph = self.repository.get_graph()
 
1752
                if self._check_if_descendant_or_diverged(
 
1753
                        stop_revision, last_rev, graph, other):
 
1754
                    # stop_revision is a descendant of last_rev, but we aren't
 
1755
                    # overwriting, so we're done.
 
1756
                    return
 
1757
                self._set_last_revision(stop_revision)
 
1758
        finally:
 
1759
            other.unlock()
2831
1760
 
2832
1761
 
2833
1762
def _extract_tar(tar, to_dir):
2873
1802
                    'Missing key %r in context %r', key_err.args[0], context)
2874
1803
                raise err
2875
1804
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
 
1805
    if err.error_verb == 'NoSuchRevision':
2880
1806
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
1807
    elif err.error_verb == 'nosuchrevision':
2882
1808
        raise NoSuchRevision(find('repository'), err.error_args[0])
2883
 
    elif err.error_verb == 'nobranch':
2884
 
        if len(err.error_args) >= 1:
2885
 
            extra = err.error_args[0]
2886
 
        else:
2887
 
            extra = None
2888
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2889
 
            detail=extra)
 
1809
    elif err.error_tuple == ('nobranch',):
 
1810
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2890
1811
    elif err.error_verb == 'norepository':
2891
1812
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
1813
    elif err.error_verb == 'LockContention':