269
271
self._real_bzrdir.destroy_branch(name=name)
270
272
self._next_open_branch_result = None
272
def create_workingtree(self, revision_id=None, from_branch=None):
274
def create_workingtree(self, revision_id=None, from_branch=None,
275
accelerator_tree=None, hardlink=False):
273
276
raise errors.NotLocalUrl(self.transport.base)
275
def find_branch_format(self):
278
def find_branch_format(self, name=None):
276
279
"""Find the branch 'format' for this bzrdir.
278
281
This might be a synthetic object for e.g. RemoteBranch and SVN.
280
b = self.open_branch()
283
b = self.open_branch(name=name)
283
def get_branch_reference(self):
286
def get_branch_reference(self, name=None):
284
287
"""See BzrDir.get_branch_reference()."""
289
# XXX JRV20100304: Support opening colocated branches
290
raise errors.NoColocatedBranchSupport(self)
285
291
response = self._get_branch_reference()
286
292
if response[0] == 'ref':
287
293
return response[1]
318
324
raise errors.UnexpectedSmartServerResponse(response)
321
def _get_tree_branch(self):
327
def _get_tree_branch(self, name=None):
322
328
"""See BzrDir._get_tree_branch()."""
323
return None, self.open_branch()
329
return None, self.open_branch(name=name)
325
331
def open_branch(self, name=None, unsupported=False,
326
332
ignore_fallbacks=False):
895
901
def _has_same_fallbacks(self, other_repo):
896
902
"""Returns true if the repositories have the same fallbacks."""
897
903
# XXX: copied from Repository; it should be unified into a base class
898
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
904
# <https://bugs.launchpad.net/bzr/+bug/401622>
899
905
my_fb = self._fallback_repositories
900
906
other_fb = other_repo._fallback_repositories
901
907
if len(my_fb) != len(other_fb):
1306
1317
return self._real_repository.make_working_trees()
1308
1319
def refresh_data(self):
1309
"""Re-read any data needed to to synchronise with disk.
1320
"""Re-read any data needed to synchronise with disk.
1311
1322
This method is intended to be called after another repository instance
1312
1323
(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.
1324
repository. On all repositories this will work outside of write groups.
1325
Some repository formats (pack and newer for bzrlib native formats)
1326
support refresh_data inside write groups. If called inside a write
1327
group on a repository that does not support refreshing in a write group
1328
IsInWriteGroupError will be raised.
1316
if self.is_in_write_group():
1317
raise errors.InternalBzrError(
1318
"May not refresh_data while in a write group.")
1319
1330
if self._real_repository is not None:
1320
1331
self._real_repository.refresh_data()
1971
1982
if response_tuple[0] != 'ok':
1972
1983
raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
1984
byte_stream = response_handler.read_streamed_body()
1974
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1985
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1986
self._record_counter)
1975
1987
if src_format.network_name() != repo._format.network_name():
1976
1988
raise AssertionError(
1977
1989
"Mismatched RemoteRepository and stream src %r, %r" % (
2357
2369
self._ensure_real()
2358
2370
return self._real_branch._get_tags_bytes()
2360
2373
def _get_tags_bytes(self):
2374
if self._tags_bytes is None:
2375
self._tags_bytes = self._get_tags_bytes_via_hpss()
2376
return self._tags_bytes
2378
def _get_tags_bytes_via_hpss(self):
2361
2379
medium = self._client._medium
2362
2380
if medium._is_remote_before((1, 13)):
2363
2381
return self._vfs_get_tags_bytes()
2396
2420
self._real_branch.lock_read()
2398
2422
self._lock_count += 1
2423
return lock.LogicalLockResult(self.unlock)
2400
2425
def _remote_lock_write(self, token):
2401
2426
if token is None:
2402
2427
branch_token = repo_token = ''
2404
2429
branch_token = token
2405
repo_token = self.repository.lock_write()
2430
repo_token = self.repository.lock_write().repository_token
2406
2431
self.repository.unlock()
2407
2432
err_context = {'token': token}
2408
response = self._call(
2409
'Branch.lock_write', self._remote_path(), branch_token,
2410
repo_token or '', **err_context)
2434
response = self._call(
2435
'Branch.lock_write', self._remote_path(), branch_token,
2436
repo_token or '', **err_context)
2437
except errors.LockContention, e:
2438
# The LockContention from the server doesn't have any
2439
# information about the lock_url. We re-raise LockContention
2440
# with valid lock_url.
2441
raise errors.LockContention('(remote lock)',
2442
self.repository.base.split('.bzr/')[0])
2411
2443
if response[0] != 'ok':
2412
2444
raise errors.UnexpectedSmartServerResponse(response)
2413
2445
ok, branch_token, repo_token = response
2445
2477
self._lock_count += 1
2446
2478
# Re-lock the repository too.
2447
2479
self.repository.lock_write(self._repo_lock_token)
2448
return self._lock_token or None
2480
return BranchWriteLockResult(self.unlock, self._lock_token or None)
2450
2482
def _unlock(self, branch_token, repo_token):
2451
2483
err_context = {'token': str((branch_token, repo_token))}
2774
2806
medium = self._branch._client._medium
2775
2807
if medium._is_remote_before((1, 14)):
2776
2808
return self._vfs_set_option(value, name, section)
2809
if isinstance(value, dict):
2810
if medium._is_remote_before((2, 2)):
2811
return self._vfs_set_option(value, name, section)
2812
return self._set_config_option_dict(value, name, section)
2814
return self._set_config_option(value, name, section)
2816
def _set_config_option(self, value, name, section):
2778
2818
path = self._branch._remote_path()
2779
2819
response = self._branch._client.call('Branch.set_config_option',
2780
2820
path, self._branch._lock_token, self._branch._repo_lock_token,
2781
2821
value.encode('utf8'), name, section or '')
2782
2822
except errors.UnknownSmartMethod:
2823
medium = self._branch._client._medium
2783
2824
medium._remember_remote_is_before((1, 14))
2784
2825
return self._vfs_set_option(value, name, section)
2785
2826
if response != ():
2786
2827
raise errors.UnexpectedSmartServerResponse(response)
2829
def _serialize_option_dict(self, option_dict):
2831
for key, value in option_dict.items():
2832
if isinstance(key, unicode):
2833
key = key.encode('utf8')
2834
if isinstance(value, unicode):
2835
value = value.encode('utf8')
2836
utf8_dict[key] = value
2837
return bencode.bencode(utf8_dict)
2839
def _set_config_option_dict(self, value, name, section):
2841
path = self._branch._remote_path()
2842
serialised_dict = self._serialize_option_dict(value)
2843
response = self._branch._client.call(
2844
'Branch.set_config_option_dict',
2845
path, self._branch._lock_token, self._branch._repo_lock_token,
2846
serialised_dict, name, section or '')
2847
except errors.UnknownSmartMethod:
2848
medium = self._branch._client._medium
2849
medium._remember_remote_is_before((2, 2))
2850
return self._vfs_set_option(value, name, section)
2852
raise errors.UnexpectedSmartServerResponse(response)
2788
2854
def _real_object(self):
2789
2855
self._branch._ensure_real()
2790
2856
return self._branch._real_branch