← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Martin Pool
  • Date: 2008-04-24 07:22:53 UTC
  • mto: This revision was merged to the branch mainline in revision 3415.
  • Revision ID: mbp@sourcefrog.net-20080424072253-opmjij7xfy38w27f
Remove every assert statement from bzrlib!

Depending on the context they are:

 * turned into an explicit if/raise of either AssertionError 
   or something more specific -- particularly where they protect
   programming interfaces, complex invariants, or data file integrity
 * removed, if they're redundant with a later check, not protecting
   a meaningful invariant
 * turned into a selftest method on tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
34
34
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
35
35
from bzrlib.config import BranchConfig, TreeConfig
36
36
from bzrlib.decorators import needs_read_lock, needs_write_lock
37
 
from bzrlib.errors import NoSuchRevision
 
37
from bzrlib.errors import (
 
38
    NoSuchRevision,
 
39
    SmartProtocolError,
 
40
    )
38
41
from bzrlib.lockable_files import LockableFiles
39
42
from bzrlib.pack import ContainerPushParser
40
43
from bzrlib.smart import client, vfs
136
139
        return None, self.open_branch()
137
140
 
138
141
    def open_branch(self, _unsupported=False):
139
 
        assert _unsupported == False, 'unsupported flag support not implemented yet.'
 
142
        if _unsupported:
 
143
            raise NotImplementedError('unsupported flag support not implemented yet.')
140
144
        reference_url = self.get_branch_reference()
141
145
        if reference_url is None:
142
146
            # branch at this location.
154
158
        except errors.UnknownSmartMethod:
155
159
            verb = 'BzrDir.find_repository'
156
160
            response = self._client.call(verb, path)
157
 
        assert response[0] in ('ok', 'norepository'), \
158
 
            'unexpected response code %s' % (response,)
159
161
        if response[0] == 'norepository':
160
162
            raise errors.NoRepositoryPresent(self)
 
163
        elif response[0] != 'ok':
 
164
            raise SmartProtocolError('unexpected response %r' 
 
165
                % response)
161
166
        if verb == 'BzrDir.find_repository':
162
167
            # servers that don't support the V2 method don't support external
163
168
            # references either.
164
169
            response = response + ('no', )
165
 
        assert len(response) == 5, 'incorrect response length %s' % (response,)
 
170
        if not (len(response) == 5):
 
171
            raise SmartProtocolError('incorrect response length %s' % (response,))
166
172
        if response[1] == '':
167
173
            format = RemoteRepositoryFormat()
168
174
            format.rich_root_data = (response[2] == 'yes')
226
232
    _matchingbzrdir = RemoteBzrDirFormat
227
233
 
228
234
    def initialize(self, a_bzrdir, shared=False):
229
 
        assert isinstance(a_bzrdir, RemoteBzrDir), \
230
 
            '%r is not a RemoteBzrDir' % (a_bzrdir,)
 
235
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
236
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
231
237
        return a_bzrdir.create_repository(shared=shared)
232
238
    
233
239
    def open(self, a_bzrdir):
234
 
        assert isinstance(a_bzrdir, RemoteBzrDir)
 
240
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
241
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
235
242
        return a_bzrdir.open_repository()
236
243
 
237
244
    def get_format_description(self):
371
378
            return {}
372
379
 
373
380
        path = self.bzrdir._path_for_remote_call(self._client)
374
 
        assert type(revision_id) is str
375
381
        response = self._client.call_expecting_body(
376
382
            'Repository.get_revision_graph', path, revision_id)
377
383
        if response[0][0] not in ['ok', 'nosuchrevision']:
390
396
            return revision_graph
391
397
        else:
392
398
            response_body = response[1].read_body_bytes()
393
 
            assert response_body == ''
 
399
            if response_body:
 
400
                raise SmartProtocolError('unexpected response body')
394
401
            raise NoSuchRevision(self, revision_id)
395
402
 
396
403
    def has_revision(self, revision_id):
400
407
            return True
401
408
        path = self.bzrdir._path_for_remote_call(self._client)
402
409
        response = self._client.call('Repository.has_revision', path, revision_id)
403
 
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
 
410
        if response[0] not in ('yes', 'no'):
 
411
            raise SmartProtocolError('unexpected response code %s' % (response,))
404
412
        return response[0] == 'yes'
405
413
 
406
414
    def has_revisions(self, revision_ids):
439
447
            fmt_committers = 'yes'
440
448
        response = self._client.call_expecting_body(
441
449
            'Repository.gather_stats', path, fmt_revid, fmt_committers)
442
 
        assert response[0][0] == 'ok', \
443
 
            'unexpected response code %s' % (response[0],)
 
450
        if response[0][0] != 'ok':
 
451
            raise SmartProtocolError('unexpected response code %s'
 
452
                % (response[0],))
444
453
 
445
454
        body = response[1].read_body_bytes()
446
455
        result = {}
483
492
        """See Repository.is_shared()."""
484
493
        path = self.bzrdir._path_for_remote_call(self._client)
485
494
        response = self._client.call('Repository.is_shared', path)
486
 
        assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
 
495
        if response[0] not in ('yes', 'no'):
 
496
            raise SmartProtocolError('unexpected response code %s' % (response,))
487
497
        return response[0] == 'yes'
488
498
 
489
499
    def is_write_locked(self):
559
569
        :param repository: The repository to fallback to for non-hpss
560
570
            implemented operations.
561
571
        """
562
 
        assert not isinstance(repository, RemoteRepository)
 
572
        if isinstance(repository, RemoteRepository):
 
573
            raise AssertionError()
563
574
        self._real_repository = repository
564
575
        if self._lock_mode == 'w':
565
576
            # if we are already locked, the real repository must be able to
859
870
        body = self._serialise_search_recipe(recipe)
860
871
        path = self.bzrdir._path_for_remote_call(self._client)
861
872
        for key in keys:
862
 
            assert type(key) is str
 
873
            if not isinstance(key, str):
 
874
                raise ValueError(key)
863
875
        verb = 'Repository.get_parent_map'
864
876
        args = (path,) + tuple(keys)
865
877
        try:
1153
1165
            path = self.bzrdir._path_for_remote_call(self._client)
1154
1166
            response = self._client.call_expecting_body(
1155
1167
                'Branch.get_config_file', path)
1156
 
            assert response[0][0] == 'ok', \
1157
 
                'unexpected response code %s' % (response[0],)
 
1168
            if response[0][0] != 'ok':
 
1169
                raise SmartProtocolError(
 
1170
                    'unexpected response code %s' % (response[0],))
1158
1171
            return StringIO(response[1].read_body_bytes())
1159
1172
        else:
1160
1173
            # VFS fallback.
1174
1187
        return 'Remote BZR Branch'
1175
1188
 
1176
1189
    def open(self, a_bzrdir):
1177
 
        assert isinstance(a_bzrdir, RemoteBzrDir)
1178
1190
        return a_bzrdir.open_branch()
1179
1191
 
1180
1192
    def initialize(self, a_bzrdir):
1181
 
        assert isinstance(a_bzrdir, RemoteBzrDir)
1182
1193
        return a_bzrdir.create_branch()
1183
1194
 
1184
1195
    def supports_tags(self):
1245
1256
        Used before calls to self._real_branch.
1246
1257
        """
1247
1258
        if not self._real_branch:
1248
 
            assert vfs.vfs_enabled()
 
1259
            if not vfs.vfs_enabled():
 
1260
                raise AssertionError('smart server vfs must be enabled '
 
1261
                    'to use vfs implementation')
1249
1262
            self.bzrdir._ensure_real()
1250
1263
            self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1251
1264
            # Give the remote repository the matching real repo.
1318
1331
        if not self._lock_mode:
1319
1332
            remote_tokens = self._remote_lock_write(token)
1320
1333
            self._lock_token, self._repo_lock_token = remote_tokens
1321
 
            assert self._lock_token, 'Remote server did not return a token!'
 
1334
            if not self._lock_token:
 
1335
                raise SmartProtocolError('Remote server did not return a token!')
1322
1336
            # TODO: We really, really, really don't want to call _ensure_real
1323
1337
            # here, but it's the easiest way to ensure coherency between the
1324
1338
            # state of the RemoteBranch and RemoteRepository objects and the
1383
1397
                # Only write-locked branched need to make a remote method call
1384
1398
                # to perfom the unlock.
1385
1399
                return
1386
 
            assert self._lock_token, 'Locked, but no token!'
 
1400
            if not self._lock_token:
 
1401
                raise AssertionError('Locked, but no token!')
1387
1402
            branch_token = self._lock_token
1388
1403
            repo_token = self._repo_lock_token
1389
1404
            self._lock_token = None
1409
1424
        """See Branch.last_revision_info()."""
1410
1425
        path = self.bzrdir._path_for_remote_call(self._client)
1411
1426
        response = self._client.call('Branch.last_revision_info', path)
1412
 
        assert response[0] == 'ok', 'unexpected response code %s' % (response,)
 
1427
        if response[0] != 'ok':
 
1428
            raise SmartProtocolError('unexpected response code %s' % (response,))
1413
1429
        revno = int(response[1])
1414
1430
        last_revision = response[2]
1415
1431
        return (revno, last_revision)
1419
1435
        path = self.bzrdir._path_for_remote_call(self._client)
1420
1436
        response = self._client.call_expecting_body(
1421
1437
            'Branch.revision_history', path)
1422
 
        assert response[0][0] == 'ok', ('unexpected response code %s'
1423
 
                                        % (response[0],))
 
1438
        if response[0][0] != 'ok':
 
1439
            raise SmartProtocolError('unexpected response code %s' % (response,))
1424
1440
        result = response[1].read_body_bytes().split('\x00')
1425
1441
        if result == ['']:
1426
1442
            return []
1441
1457
            path, self._lock_token, self._repo_lock_token, rev_id)
1442
1458
        if response[0] == 'NoSuchRevision':
1443
1459
            raise NoSuchRevision(self, rev_id)
1444
 
        else:
1445
 
            assert response == ('ok',), (
1446
 
                'unexpected response code %r' % (response,))
 
1460
        elif response[0] != 'ok':
 
1461
            raise SmartProtocolError('unexpected response code %s' % (response,))
1447
1462
        self._cache_revision_history(rev_history)
1448
1463
 
1449
1464
    def get_parent(self):
1493
1508
 
1494
1509
    @needs_write_lock
1495
1510
    def set_last_revision_info(self, revno, revision_id):
1496
 
        assert type(revno) is int
1497
1511
        revision_id = ensure_null(revision_id)
1498
1512
        path = self.bzrdir._path_for_remote_call(self._client)
1499
1513
        try: