This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10899

censor: extract the part about writing the other revision in a function
ClosedPublic

Authored by marmoute on Jun 22 2021, 7:27 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9b70aa7bcbab: censor: extract the part about writing the other revision in a function
Summary

The v2_censor function is huge, now that its content has settled a bit it is a
good time to split individual part inside dedicated function.

We continue with a small function that add a non-censored revision back to the
revlog.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Jun 22 2021, 7:27 PM
Alphare accepted this revision.Jul 1 2021, 4:49 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
mercurial/revlogutils/rewrite.py
294

Nit: why the quotes around "normal"? I would use "unchanged" to be clearer maybe?

This revision is now accepted and ready to land.Jul 1 2021, 4:49 AM
marmoute added inline comments.Jul 1 2021, 4:58 AM
mercurial/revlogutils/rewrite.py
294

The delta might have been changed. So it is not really "unchanged".

Revision Contents
Changeset List

PathPackages
Mmercurial/revlogutils/rewrite.py (143 lines)

Diff 28710

mercurial/revlogutils/rewrite.py

_rewrite_censor( _rewrite_censor(
rl, rl,
old_index, old_index,
open_files, open_files,
censor_rev, censor_rev,
tombstone, tombstone,
) )
#### Writing all subsequent revisions # Writing all subsequent revisions
for rev in range(censor_rev + 1, len(old_index)): for rev in range(censor_rev + 1, len(old_index)):
_rewrite_simple(
rl,
old_index,
open_files,
rev,
rewritten_entries,
tmp_storage,
)
docket.write(transaction=None, stripping=True)
def _rewrite_simple(
revlog,
old_index,
all_files,
rev,
rewritten_entries,
tmp_storage,
):
"""append a normal revision to the index after the rewritten one(s)"""
AlphareUnsubmitted
Not Done

Nit: why the quotes around "normal"? I would use "unchanged" to be clearer maybe?

Alphare: Nit: why the quotes around "normal"? I would use "unchanged" to be clearer maybe?
marmouteAuthorUnsubmitted
Done

The delta might have been changed. So it is not really "unchanged".

marmoute: The delta might have been changed. So it is not really "unchanged".
(
old_data_file,
old_sidedata_file,
new_index_file,
new_data_file,
new_sidedata_file,
) = all_files
entry = old_index[rev] entry = old_index[rev]
flags = entry[ENTRY_DATA_OFFSET] & 0xFFFF flags = entry[ENTRY_DATA_OFFSET] & 0xFFFF
old_data_offset = entry[ENTRY_DATA_OFFSET] >> 16 old_data_offset = entry[ENTRY_DATA_OFFSET] >> 16
if rev not in rewritten_entries: if rev not in rewritten_entries:
old_data_file.seek(old_data_offset) old_data_file.seek(old_data_offset)
new_data_size = entry[ENTRY_DATA_COMPRESSED_LENGTH] new_data_size = entry[ENTRY_DATA_COMPRESSED_LENGTH]
new_data = old_data_file.read(new_data_size) new_data = old_data_file.read(new_data_size)
data_delta_base = entry[ENTRY_DELTA_BASE] data_delta_base = entry[ENTRY_DELTA_BASE]
d_comp_mode = entry[ENTRY_DATA_COMPRESSION_MODE] d_comp_mode = entry[ENTRY_DATA_COMPRESSION_MODE]
else: else:
( (
data_delta_base, data_delta_base,
start, start,
end, end,
d_comp_mode, d_comp_mode,
) = rewritten_entries[rev] ) = rewritten_entries[rev]
new_data_size = end - start new_data_size = end - start
tmp_storage.seek(start) tmp_storage.seek(start)
new_data = tmp_storage.read(new_data_size) new_data = tmp_storage.read(new_data_size)
# It might be faster to group continuous read/write operation, # It might be faster to group continuous read/write operation,
# however, this is censor, an operation that is not focussed # however, this is censor, an operation that is not focussed
# around stellar performance. So I have not written this # around stellar performance. So I have not written this
# optimisation yet. # optimisation yet.
new_data_offset = new_data_file.tell() new_data_offset = new_data_file.tell()
new_data_file.write(new_data) new_data_file.write(new_data)
sidedata_size = entry[ENTRY_SIDEDATA_COMPRESSED_LENGTH] sidedata_size = entry[ENTRY_SIDEDATA_COMPRESSED_LENGTH]
new_sidedata_offset = new_sidedata_file.tell() new_sidedata_offset = new_sidedata_file.tell()
if 0 < sidedata_size: if 0 < sidedata_size:
old_sidedata_offset = entry[ENTRY_SIDEDATA_OFFSET] old_sidedata_offset = entry[ENTRY_SIDEDATA_OFFSET]
old_sidedata_file.seek(old_sidedata_offset) old_sidedata_file.seek(old_sidedata_offset)
new_sidedata = old_sidedata_file.read(sidedata_size) new_sidedata = old_sidedata_file.read(sidedata_size)
new_sidedata_file.write(new_sidedata) new_sidedata_file.write(new_sidedata)
data_uncompressed_length = entry[ENTRY_DATA_UNCOMPRESSED_LENGTH] data_uncompressed_length = entry[ENTRY_DATA_UNCOMPRESSED_LENGTH]
sd_com_mode = entry[ENTRY_SIDEDATA_COMPRESSION_MODE] sd_com_mode = entry[ENTRY_SIDEDATA_COMPRESSION_MODE]
assert data_delta_base <= rev, (data_delta_base, rev) assert data_delta_base <= rev, (data_delta_base, rev)
new_entry = revlogutils.entry( new_entry = revlogutils.entry(
flags=flags, flags=flags,
data_offset=new_data_offset, data_offset=new_data_offset,
data_compressed_length=new_data_size, data_compressed_length=new_data_size,
data_uncompressed_length=data_uncompressed_length, data_uncompressed_length=data_uncompressed_length,
data_delta_base=data_delta_base, data_delta_base=data_delta_base,
link_rev=entry[ENTRY_LINK_REV], link_rev=entry[ENTRY_LINK_REV],
parent_rev_1=entry[ENTRY_PARENT_1], parent_rev_1=entry[ENTRY_PARENT_1],
parent_rev_2=entry[ENTRY_PARENT_2], parent_rev_2=entry[ENTRY_PARENT_2],
node_id=entry[ENTRY_NODE_ID], node_id=entry[ENTRY_NODE_ID],
sidedata_offset=new_sidedata_offset, sidedata_offset=new_sidedata_offset,
sidedata_compressed_length=sidedata_size, sidedata_compressed_length=sidedata_size,
data_compression_mode=d_comp_mode, data_compression_mode=d_comp_mode,
sidedata_compression_mode=sd_com_mode, sidedata_compression_mode=sd_com_mode,
) )
rl.index.append(new_entry) revlog.index.append(new_entry)
entry_bin = rl.index.entry_binary(rev) entry_bin = revlog.index.entry_binary(rev)
new_index_file.write(entry_bin) new_index_file.write(entry_bin)
docket.index_end = new_index_file.tell() revlog._docket.index_end = new_index_file.tell()
docket.data_end = new_data_file.tell() revlog._docket.data_end = new_data_file.tell()
docket.sidedata_end = new_sidedata_file.tell() revlog._docket.sidedata_end = new_sidedata_file.tell()
docket.write(transaction=None, stripping=True)
def _rewrite_censor( def _rewrite_censor(
revlog, revlog,
old_index, old_index,
all_files, all_files,
rev, rev,
tombstone, tombstone,