← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/repository.py

  • Committer: Martin Packman
  • Date: 2011-11-23 18:59:43 UTC
  • mto: This revision was merged to the branch mainline in revision 6304.
  • Revision ID: martin.packman@canonical.com-20111123185943-1s2ltxqt5ugohh0w
Add full stops to various registry help strings

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/repository.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Server-side repository related request implementations."""
18
 
 
19
 
from __future__ import absolute_import
 
17
"""Server-side repository related request implmentations."""
20
18
 
21
19
import bz2
22
20
import os
24
22
import sys
25
23
import tempfile
26
24
import threading
27
 
import zlib
28
25
 
29
26
from bzrlib import (
30
27
    bencode,
 
28
    commands,
31
29
    errors,
32
30
    estimate_compressed_size,
33
 
    inventory as _mod_inventory,
34
 
    inventory_delta,
 
31
    graph,
35
32
    osutils,
36
33
    pack,
37
34
    trace,
38
35
    ui,
39
 
    vf_search,
40
36
    )
41
37
from bzrlib.bzrdir import BzrDir
42
38
from bzrlib.smart.request import (
47
43
from bzrlib.repository import _strip_NULL_ghosts, network_format_registry
48
44
from bzrlib import revision as _mod_revision
49
45
from bzrlib.versionedfile import (
50
 
    ChunkedContentFactory,
51
46
    NetworkRecordStream,
52
47
    record_to_fulltext_bytes,
53
48
    )
90
85
            they expected and get it from elsewhere.
91
86
        """
92
87
        if search_bytes == 'everything':
93
 
            return vf_search.EverythingResult(repository), None
 
88
            return graph.EverythingResult(repository), None
94
89
        lines = search_bytes.split('\n')
95
90
        if lines[0] == 'ancestry-of':
96
91
            heads = lines[1:]
97
 
            search_result = vf_search.PendingAncestryResult(heads, repository)
 
92
            search_result = graph.PendingAncestryResult(heads, repository)
98
93
            return search_result, None
99
94
        elif lines[0] == 'search':
100
95
            return self.recreate_search_from_recipe(repository, lines[1:],
124
119
                except StopIteration:
125
120
                    break
126
121
                search.stop_searching_any(exclude_keys.intersection(next_revs))
127
 
            (started_keys, excludes, included_keys) = search.get_state()
128
 
            if (not discard_excess and len(included_keys) != revision_count):
 
122
            search_result = search.get_result()
 
123
            if (not discard_excess and
 
124
                search_result.get_recipe()[3] != revision_count):
129
125
                # we got back a different amount of data than expected, this
130
126
                # gets reported as NoSuchRevision, because less revisions
131
127
                # indicates missing revisions, and more should never happen as
132
128
                # the excludes list considers ghosts and ensures that ghost
133
129
                # filling races are not a problem.
134
130
                return (None, FailedSmartServerResponse(('NoSuchRevision',)))
135
 
            search_result = vf_search.SearchResult(started_keys, excludes,
136
 
                len(included_keys), included_keys)
137
131
            return (search_result, None)
138
132
        finally:
139
133
            repository.unlock()
150
144
        finally:
151
145
            repository.unlock()
152
146
 
153
 
 
154
 
class SmartServerRepositoryBreakLock(SmartServerRepositoryRequest):
155
 
    """Break a repository lock."""
156
 
 
157
 
    def do_repository_request(self, repository):
158
 
        repository.break_lock()
159
 
        return SuccessfulSmartServerResponse(('ok', ))
160
 
 
161
 
 
162
147
_lsprof_count = 0
163
148
 
164
149
class SmartServerRepositoryGetParentMap(SmartServerRepositoryRequest):
342
327
                ('history-incomplete', earliest_revno, earliest_revid))
343
328
 
344
329
 
345
 
class SmartServerRepositoryGetSerializerFormat(SmartServerRepositoryRequest):
346
 
 
347
 
    def do_repository_request(self, repository):
348
 
        """Return the serializer format for this repository.
349
 
 
350
 
        New in 2.5.0.
351
 
 
352
 
        :param repository: The repository to query
353
 
        :return: A smart server response ('ok', FORMAT)
354
 
        """
355
 
        serializer = repository.get_serializer_format()
356
 
        return SuccessfulSmartServerResponse(('ok', serializer))
357
 
 
358
 
 
359
330
class SmartServerRequestHasRevision(SmartServerRepositoryRequest):
360
331
 
361
332
    def do_repository_request(self, repository, revision_id):
363
334
 
364
335
        :param repository: The repository to query in.
365
336
        :param revision_id: The utf8 encoded revision_id to lookup.
366
 
        :return: A smart server response of ('yes', ) if the revision is
367
 
            present. ('no', ) if it is missing.
 
337
        :return: A smart server response of ('ok', ) if the revision is
 
338
            present.
368
339
        """
369
340
        if repository.has_revision(revision_id):
370
341
            return SuccessfulSmartServerResponse(('yes', ))
372
343
            return SuccessfulSmartServerResponse(('no', ))
373
344
 
374
345
 
375
 
class SmartServerRequestHasSignatureForRevisionId(
376
 
        SmartServerRepositoryRequest):
377
 
 
378
 
    def do_repository_request(self, repository, revision_id):
379
 
        """Return ok if a signature is present for a revision.
380
 
 
381
 
        Introduced in bzr 2.5.0.
382
 
 
383
 
        :param repository: The repository to query in.
384
 
        :param revision_id: The utf8 encoded revision_id to lookup.
385
 
        :return: A smart server response of ('yes', ) if a
386
 
            signature for the revision is present,
387
 
            ('no', ) if it is missing.
388
 
        """
389
 
        try:
390
 
            if repository.has_signature_for_revision_id(revision_id):
391
 
                return SuccessfulSmartServerResponse(('yes', ))
392
 
            else:
393
 
                return SuccessfulSmartServerResponse(('no', ))
394
 
        except errors.NoSuchRevision:
395
 
            return FailedSmartServerResponse(
396
 
                ('nosuchrevision', revision_id))
397
 
 
398
 
 
399
346
class SmartServerRepositoryGatherStats(SmartServerRepositoryRequest):
400
347
 
401
348
    def do_repository_request(self, repository, revid, committers):
421
368
            decoded_committers = True
422
369
        else:
423
370
            decoded_committers = None
424
 
        try:
425
 
            stats = repository.gather_stats(decoded_revision_id,
426
 
                decoded_committers)
427
 
        except errors.NoSuchRevision:
428
 
            return FailedSmartServerResponse(('nosuchrevision', revid))
 
371
        stats = repository.gather_stats(decoded_revision_id, decoded_committers)
429
372
 
430
373
        body = ''
431
374
        if stats.has_key('committers'):
442
385
        return SuccessfulSmartServerResponse(('ok', ), body)
443
386
 
444
387
 
445
 
class SmartServerRepositoryGetRevisionSignatureText(
446
 
        SmartServerRepositoryRequest):
447
 
    """Return the signature text of a revision.
448
 
 
449
 
    New in 2.5.
450
 
    """
451
 
 
452
 
    def do_repository_request(self, repository, revision_id):
453
 
        """Return the result of repository.get_signature_text().
454
 
 
455
 
        :param repository: The repository to query in.
456
 
        :return: A smart server response of with the signature text as
457
 
            body.
458
 
        """
459
 
        try:
460
 
            text = repository.get_signature_text(revision_id)
461
 
        except errors.NoSuchRevision, err:
462
 
            return FailedSmartServerResponse(
463
 
                ('nosuchrevision', err.revision))
464
 
        return SuccessfulSmartServerResponse(('ok', ), text)
465
 
 
466
 
 
467
388
class SmartServerRepositoryIsShared(SmartServerRepositoryRequest):
468
389
 
469
390
    def do_repository_request(self, repository):
479
400
            return SuccessfulSmartServerResponse(('no', ))
480
401
 
481
402
 
482
 
class SmartServerRepositoryMakeWorkingTrees(SmartServerRepositoryRequest):
483
 
 
484
 
    def do_repository_request(self, repository):
485
 
        """Return the result of repository.make_working_trees().
486
 
 
487
 
        Introduced in bzr 2.5.0.
488
 
 
489
 
        :param repository: The repository to query in.
490
 
        :return: A smart server response of ('yes', ) if the repository uses
491
 
            working trees, and ('no', ) if it is not.
492
 
        """
493
 
        if repository.make_working_trees():
494
 
            return SuccessfulSmartServerResponse(('yes', ))
495
 
        else:
496
 
            return SuccessfulSmartServerResponse(('no', ))
497
 
 
498
 
 
499
403
class SmartServerRepositoryLockWrite(SmartServerRepositoryRequest):
500
404
 
501
405
    def do_repository_request(self, repository, token=''):
782
686
        return SuccessfulSmartServerResponse(('ok',))
783
687
 
784
688
 
785
 
class SmartServerRepositoryGetPhysicalLockStatus(SmartServerRepositoryRequest):
786
 
    """Get the physical lock status for a repository.
787
 
 
788
 
    New in 2.5.
789
 
    """
790
 
 
791
 
    def do_repository_request(self, repository):
792
 
        if repository.get_physical_lock_status():
793
 
            return SuccessfulSmartServerResponse(('yes', ))
794
 
        else:
795
 
            return SuccessfulSmartServerResponse(('no', ))
796
 
 
797
 
 
798
689
class SmartServerRepositorySetMakeWorkingTrees(SmartServerRepositoryRequest):
799
690
 
800
691
    def do_repository_request(self, repository, str_bool_new_value):
963
854
        self.do_insert_stream_request(repository, resume_tokens)
964
855
 
965
856
 
966
 
class SmartServerRepositoryAddSignatureText(SmartServerRepositoryRequest):
967
 
    """Add a revision signature text.
968
 
 
969
 
    New in 2.5.
970
 
    """
971
 
 
972
 
    def do_repository_request(self, repository, lock_token, revision_id,
973
 
            *write_group_tokens):
974
 
        """Add a revision signature text.
975
 
 
976
 
        :param repository: Repository to operate on
977
 
        :param lock_token: Lock token
978
 
        :param revision_id: Revision for which to add signature
979
 
        :param write_group_tokens: Write group tokens
980
 
        """
981
 
        self._lock_token = lock_token
982
 
        self._revision_id = revision_id
983
 
        self._write_group_tokens = write_group_tokens
984
 
        return None
985
 
 
986
 
    def do_body(self, body_bytes):
987
 
        """Add a signature text.
988
 
 
989
 
        :param body_bytes: GPG signature text
990
 
        :return: SuccessfulSmartServerResponse with arguments 'ok' and
991
 
            the list of new write group tokens.
992
 
        """
993
 
        self._repository.lock_write(token=self._lock_token)
994
 
        try:
995
 
            self._repository.resume_write_group(self._write_group_tokens)
996
 
            try:
997
 
                self._repository.add_signature_text(self._revision_id,
998
 
                    body_bytes)
999
 
            finally:
1000
 
                new_write_group_tokens = self._repository.suspend_write_group()
1001
 
        finally:
1002
 
            self._repository.unlock()
1003
 
        return SuccessfulSmartServerResponse(
1004
 
            ('ok', ) + tuple(new_write_group_tokens))
1005
 
 
1006
 
 
1007
 
class SmartServerRepositoryStartWriteGroup(SmartServerRepositoryRequest):
1008
 
    """Start a write group.
1009
 
 
1010
 
    New in 2.5.
1011
 
    """
1012
 
 
1013
 
    def do_repository_request(self, repository, lock_token):
1014
 
        """Start a write group."""
1015
 
        repository.lock_write(token=lock_token)
1016
 
        try:
1017
 
            repository.start_write_group()
1018
 
            try:
1019
 
                tokens = repository.suspend_write_group()
1020
 
            except errors.UnsuspendableWriteGroup:
1021
 
                return FailedSmartServerResponse(('UnsuspendableWriteGroup',))
1022
 
        finally:
1023
 
            repository.unlock()
1024
 
        return SuccessfulSmartServerResponse(('ok', tokens))
1025
 
 
1026
 
 
1027
 
class SmartServerRepositoryCommitWriteGroup(SmartServerRepositoryRequest):
1028
 
    """Commit a write group.
1029
 
 
1030
 
    New in 2.5.
1031
 
    """
1032
 
 
1033
 
    def do_repository_request(self, repository, lock_token,
1034
 
            write_group_tokens):
1035
 
        """Commit a write group."""
1036
 
        repository.lock_write(token=lock_token)
1037
 
        try:
1038
 
            try:
1039
 
                repository.resume_write_group(write_group_tokens)
1040
 
            except errors.UnresumableWriteGroup, e:
1041
 
                return FailedSmartServerResponse(
1042
 
                    ('UnresumableWriteGroup', e.write_groups, e.reason))
1043
 
            try:
1044
 
                repository.commit_write_group()
1045
 
            except:
1046
 
                write_group_tokens = repository.suspend_write_group()
1047
 
                # FIXME JRV 2011-11-19: What if the write_group_tokens
1048
 
                # have changed?
1049
 
                raise
1050
 
        finally:
1051
 
            repository.unlock()
1052
 
        return SuccessfulSmartServerResponse(('ok', ))
1053
 
 
1054
 
 
1055
 
class SmartServerRepositoryAbortWriteGroup(SmartServerRepositoryRequest):
1056
 
    """Abort a write group.
1057
 
 
1058
 
    New in 2.5.
1059
 
    """
1060
 
 
1061
 
    def do_repository_request(self, repository, lock_token, write_group_tokens):
1062
 
        """Abort a write group."""
1063
 
        repository.lock_write(token=lock_token)
1064
 
        try:
1065
 
            try:
1066
 
                repository.resume_write_group(write_group_tokens)
1067
 
            except errors.UnresumableWriteGroup, e:
1068
 
                return FailedSmartServerResponse(
1069
 
                    ('UnresumableWriteGroup', e.write_groups, e.reason))
1070
 
                repository.abort_write_group()
1071
 
        finally:
1072
 
            repository.unlock()
1073
 
        return SuccessfulSmartServerResponse(('ok', ))
1074
 
 
1075
 
 
1076
 
class SmartServerRepositoryCheckWriteGroup(SmartServerRepositoryRequest):
1077
 
    """Check that a write group is still valid.
1078
 
 
1079
 
    New in 2.5.
1080
 
    """
1081
 
 
1082
 
    def do_repository_request(self, repository, lock_token, write_group_tokens):
1083
 
        """Abort a write group."""
1084
 
        repository.lock_write(token=lock_token)
1085
 
        try:
1086
 
            try:
1087
 
                repository.resume_write_group(write_group_tokens)
1088
 
            except errors.UnresumableWriteGroup, e:
1089
 
                return FailedSmartServerResponse(
1090
 
                    ('UnresumableWriteGroup', e.write_groups, e.reason))
1091
 
            else:
1092
 
                repository.suspend_write_group()
1093
 
        finally:
1094
 
            repository.unlock()
1095
 
        return SuccessfulSmartServerResponse(('ok', ))
1096
 
 
1097
 
 
1098
 
class SmartServerRepositoryAllRevisionIds(SmartServerRepositoryRequest):
1099
 
    """Retrieve all of the revision ids in a repository.
1100
 
 
1101
 
    New in 2.5.
1102
 
    """
1103
 
 
1104
 
    def do_repository_request(self, repository):
1105
 
        revids = repository.all_revision_ids()
1106
 
        return SuccessfulSmartServerResponse(("ok", ), "\n".join(revids))
1107
 
 
1108
 
 
1109
 
class SmartServerRepositoryReconcile(SmartServerRepositoryRequest):
1110
 
    """Reconcile a repository.
1111
 
 
1112
 
    New in 2.5.
1113
 
    """
1114
 
 
1115
 
    def do_repository_request(self, repository, lock_token):
1116
 
        try:
1117
 
            repository.lock_write(token=lock_token)
1118
 
        except errors.TokenLockingNotSupported, e:
1119
 
            return FailedSmartServerResponse(
1120
 
                ('TokenLockingNotSupported', ))
1121
 
        try:
1122
 
            reconciler = repository.reconcile()
1123
 
        finally:
1124
 
            repository.unlock()
1125
 
        body = [
1126
 
            "garbage_inventories: %d\n" % reconciler.garbage_inventories,
1127
 
            "inconsistent_parents: %d\n" % reconciler.inconsistent_parents,
1128
 
            ]
1129
 
        return SuccessfulSmartServerResponse(('ok', ), "".join(body))
1130
 
 
1131
 
 
1132
 
class SmartServerRepositoryPack(SmartServerRepositoryRequest):
1133
 
    """Pack a repository.
1134
 
 
1135
 
    New in 2.5.
1136
 
    """
1137
 
 
1138
 
    def do_repository_request(self, repository, lock_token, clean_obsolete_packs):
1139
 
        self._repository = repository
1140
 
        self._lock_token = lock_token
1141
 
        if clean_obsolete_packs == 'True':
1142
 
            self._clean_obsolete_packs = True
1143
 
        else:
1144
 
            self._clean_obsolete_packs = False
1145
 
        return None
1146
 
 
1147
 
    def do_body(self, body_bytes):
1148
 
        if body_bytes == "":
1149
 
            hint = None
1150
 
        else:
1151
 
            hint = body_bytes.splitlines()
1152
 
        self._repository.lock_write(token=self._lock_token)
1153
 
        try:
1154
 
            self._repository.pack(hint, self._clean_obsolete_packs)
1155
 
        finally:
1156
 
            self._repository.unlock()
1157
 
        return SuccessfulSmartServerResponse(("ok", ), )
1158
 
 
1159
 
 
1160
 
class SmartServerRepositoryIterFilesBytes(SmartServerRepositoryRequest):
1161
 
    """Iterate over the contents of files.
1162
 
 
1163
 
    The client sends a list of desired files to stream, one
1164
 
    per line, and as tuples of file id and revision, separated by
1165
 
    \0.
1166
 
 
1167
 
    The server replies with a stream. Each entry is preceded by a header,
1168
 
    which can either be:
1169
 
 
1170
 
    * "ok\x00IDX\n" where IDX is the index of the entry in the desired files
1171
 
        list sent by the client. This header is followed by the contents of
1172
 
        the file, bzip2-compressed.
1173
 
    * "absent\x00FILEID\x00REVISION\x00IDX" to indicate a text is missing.
1174
 
        The client can then raise an appropriate RevisionNotPresent error
1175
 
        or check its fallback repositories.
1176
 
 
1177
 
    New in 2.5.
1178
 
    """
1179
 
 
1180
 
    def body_stream(self, repository, desired_files):
1181
 
        self._repository.lock_read()
1182
 
        try:
1183
 
            text_keys = {}
1184
 
            for i, key in enumerate(desired_files):
1185
 
                text_keys[key] = i
1186
 
            for record in repository.texts.get_record_stream(text_keys,
1187
 
                    'unordered', True):
1188
 
                identifier = text_keys[record.key]
1189
 
                if record.storage_kind == 'absent':
1190
 
                    yield "absent\0%s\0%s\0%d\n" % (record.key[0],
1191
 
                        record.key[1], identifier)
1192
 
                    # FIXME: Way to abort early?
1193
 
                    continue
1194
 
                yield "ok\0%d\n" % identifier
1195
 
                compressor = zlib.compressobj()
1196
 
                for bytes in record.get_bytes_as('chunked'):
1197
 
                    data = compressor.compress(bytes)
1198
 
                    if data:
1199
 
                        yield data
1200
 
                data = compressor.flush()
1201
 
                if data:
1202
 
                    yield data
1203
 
        finally:
1204
 
            self._repository.unlock()
1205
 
 
1206
 
    def do_body(self, body_bytes):
1207
 
        desired_files = [
1208
 
            tuple(l.split("\0")) for l in body_bytes.splitlines()]
1209
 
        return SuccessfulSmartServerResponse(('ok', ),
1210
 
            body_stream=self.body_stream(self._repository, desired_files))
1211
 
 
1212
 
    def do_repository_request(self, repository):
1213
 
        # Signal that we want a body
1214
 
        return None
1215
 
 
1216
 
 
1217
 
class SmartServerRepositoryIterRevisions(SmartServerRepositoryRequest):
1218
 
    """Stream a list of revisions.
1219
 
 
1220
 
    The client sends a list of newline-separated revision ids in the
1221
 
    body of the request and the server replies with the serializer format,
1222
 
    and a stream of bzip2-compressed revision texts (using the specified
1223
 
    serializer format).
1224
 
 
1225
 
    Any revisions the server does not have are omitted from the stream.
1226
 
 
1227
 
    New in 2.5.
1228
 
    """
1229
 
 
1230
 
    def do_repository_request(self, repository):
1231
 
        self._repository = repository
1232
 
        # Signal there is a body
1233
 
        return None
1234
 
 
1235
 
    def do_body(self, body_bytes):
1236
 
        revision_ids = body_bytes.split("\n")
1237
 
        return SuccessfulSmartServerResponse(
1238
 
            ('ok', self._repository.get_serializer_format()),
1239
 
            body_stream=self.body_stream(self._repository, revision_ids))
1240
 
 
1241
 
    def body_stream(self, repository, revision_ids):
1242
 
        self._repository.lock_read()
1243
 
        try:
1244
 
            for record in repository.revisions.get_record_stream(
1245
 
                [(revid,) for revid in revision_ids], 'unordered', True):
1246
 
                if record.storage_kind == 'absent':
1247
 
                    continue
1248
 
                yield zlib.compress(record.get_bytes_as('fulltext'))
1249
 
        finally:
1250
 
            self._repository.unlock()
1251
 
 
1252
 
 
1253
 
class SmartServerRepositoryGetInventories(SmartServerRepositoryRequest):
1254
 
    """Get the inventory deltas for a set of revision ids.
1255
 
 
1256
 
    This accepts a list of revision ids, and then sends a chain
1257
 
    of deltas for the inventories of those revisions. The first
1258
 
    revision will be empty.
1259
 
 
1260
 
    The server writes back zlibbed serialized inventory deltas,
1261
 
    in the ordering specified. The base for each delta is the
1262
 
    inventory generated by the previous delta.
1263
 
 
1264
 
    New in 2.5.
1265
 
    """
1266
 
 
1267
 
    def _inventory_delta_stream(self, repository, ordering, revids):
1268
 
        prev_inv = _mod_inventory.Inventory(root_id=None,
1269
 
            revision_id=_mod_revision.NULL_REVISION)
1270
 
        serializer = inventory_delta.InventoryDeltaSerializer(
1271
 
            repository.supports_rich_root(),
1272
 
            repository._format.supports_tree_reference)
1273
 
        repository.lock_read()
1274
 
        try:
1275
 
            for inv, revid in repository._iter_inventories(revids, ordering):
1276
 
                if inv is None:
1277
 
                    continue
1278
 
                inv_delta = inv._make_delta(prev_inv)
1279
 
                lines = serializer.delta_to_lines(
1280
 
                    prev_inv.revision_id, inv.revision_id, inv_delta)
1281
 
                yield ChunkedContentFactory(inv.revision_id, None, None, lines)
1282
 
                prev_inv = inv
1283
 
        finally:
1284
 
            repository.unlock()
1285
 
 
1286
 
    def body_stream(self, repository, ordering, revids):
1287
 
        substream = self._inventory_delta_stream(repository,
1288
 
            ordering, revids)
1289
 
        return _stream_to_byte_stream([('inventory-deltas', substream)],
1290
 
            repository._format)
1291
 
 
1292
 
    def do_body(self, body_bytes):
1293
 
        return SuccessfulSmartServerResponse(('ok', ),
1294
 
            body_stream=self.body_stream(self._repository, self._ordering,
1295
 
                body_bytes.splitlines()))
1296
 
 
1297
 
    def do_repository_request(self, repository, ordering):
1298
 
        if ordering == 'unordered':
1299
 
            # inventory deltas for a topologically sorted stream
1300
 
            # are likely to be smaller
1301
 
            ordering = 'topological'
1302
 
        self._ordering = ordering
1303
 
        # Signal that we want a body
1304
 
        return None