sigonasr2/AdventuresInLestoria
1
1
Fork 0
Code Issues 20 Pull Requests 1 Actions Projects 1 Releases Wiki Activity
AdventuresInLestoria/git-filter-repo

4005 lines
162 KiB
Python
Raw Blame History

#!/usr/bin/env python3
"""
git-filter-repo filters git repositories, similar to git filter-branch, BFG
repo cleaner, and others. The basic idea is that it works by running
git fast-export <options> | filter | git fast-import <options>
where this program not only launches the whole pipeline but also serves as
the 'filter' in the middle. It does a few additional things on top as well
in order to make it into a well-rounded filtering tool.
git-filter-repo can also be used as a library for more involved filtering
operations; however:
***** API BACKWARD COMPATIBILITY CAVEAT *****
Programs using git-filter-repo as a library can reach pretty far into its
internals, but I am not prepared to guarantee backward compatibility of
all APIs. I suspect changes will be rare, but I reserve the right to
change any API. Since it is assumed that repository filtering is
something one would do very rarely, and in particular that it's a
one-shot operation, this should not be a problem in practice for anyone.
However, if you want to re-use a program you have written that uses
git-filter-repo as a library (or makes use of one of its --*-callback
arguments), you should either make sure you are using the same version of
git and git-filter-repo, or make sure to re-test it.
If there are particular pieces of the API you are concerned about, and
there is not already a testcase for it in t9391-lib-usage.sh or
t9392-python-callback.sh, please contribute a testcase. That will not
prevent me from changing the API, but it will allow you to look at the
history of a testcase to see whether and how the API changed.
***** END API BACKWARD COMPATIBILITY CAVEAT *****
"""
import argparse
import collections
import fnmatch
import gettext
import io
import os
import platform
import re
import shutil
import subprocess
import sys
import time
import textwrap
from datetime import tzinfo, timedelta, datetime
__all__ = ["Blob", "Reset", "FileChange", "Commit", "Tag", "Progress",
"Checkpoint", "FastExportParser", "ProgressWriter",
"string_to_date", "date_to_string",
"record_id_rename", "GitUtils", "FilteringOptions", "RepoFilter"]
deleted_hash = b'0'*40
write_marks = True
date_format_permissive = True
def gettext_poison(msg):
if "GIT_TEST_GETTEXT_POISON" in os.environ: # pragma: no cover
return "# GETTEXT POISON #"
return gettext.gettext(msg)
_ = gettext_poison
def setup_gettext():
TEXTDOMAIN="git-filter-repo"
podir = os.environ.get("GIT_TEXTDOMAINDIR") or "@@LOCALEDIR@@"
if not os.path.isdir(podir): # pragma: no cover
podir = None # Python has its own fallback; use that
## This looks like the most straightforward translation of the relevant
## code in git.git:gettext.c and git.git:perl/Git/I18n.pm:
#import locale
#locale.setlocale(locale.LC_MESSAGES, "");
#locale.setlocale(locale.LC_TIME, "");
#locale.textdomain(TEXTDOMAIN);
#locale.bindtextdomain(TEXTDOMAIN, podir);
## but the python docs suggest using the gettext module (which doesn't
## have setlocale()) instead, so:
gettext.textdomain(TEXTDOMAIN);
gettext.bindtextdomain(TEXTDOMAIN, podir);
def _timedelta_to_seconds(delta):
"""
Converts timedelta to seconds
"""
offset = delta.days*86400 + delta.seconds + (delta.microseconds+0.0)/1000000
return round(offset)
class FixedTimeZone(tzinfo):
"""
Fixed offset in minutes east from UTC.
"""
tz_re = re.compile(br'^([-+]?)(\d\d)(\d\d)$')
def __init__(self, offset_string):
tzinfo.__init__(self)
sign, hh, mm = FixedTimeZone.tz_re.match(offset_string).groups()
factor = -1 if (sign and sign == b'-') else 1
self._offset = timedelta(minutes = factor*(60*int(hh) + int(mm)))
self._offset_string = offset_string
def utcoffset(self, dt):
return self._offset
def tzname(self, dt):
return self._offset_string
def dst(self, dt):
return timedelta(0)
def string_to_date(datestring):
(unix_timestamp, tz_offset) = datestring.split()
return datetime.fromtimestamp(int(unix_timestamp),
FixedTimeZone(tz_offset))
def date_to_string(dateobj):
epoch = datetime.fromtimestamp(0, dateobj.tzinfo)
return(b'%d %s' % (int(_timedelta_to_seconds(dateobj - epoch)),
dateobj.tzinfo.tzname(0)))
def decode(bytestr):
'Try to convert bytestr to utf-8 for outputting as an error message.'
return bytestr.decode('utf-8', 'backslashreplace')
def glob_to_regex(glob_bytestr):
'Translate glob_bytestr into a regex on bytestrings'
# fnmatch.translate is idiotic and won't accept bytestrings
if (decode(glob_bytestr).encode() != glob_bytestr): # pragma: no cover
raise SystemExit(_("Error: Cannot handle glob %s").format(glob_bytestr))
# Create regex operating on string
regex = fnmatch.translate(decode(glob_bytestr))
# FIXME: This is an ugly hack...
# fnmatch.translate tries to do multi-line matching and wants the glob to
# match up to the end of the input, which isn't relevant for us, so we
# have to modify the regex. fnmatch.translate has used different regex
# constructs to achieve this with different python versions, so we have
# to check for each of them and then fix it up. It would be much better
# if fnmatch.translate could just take some flags to allow us to specify
# what we want rather than employing this hackery, but since it
# doesn't...
if regex.endswith(r'\Z(?ms)'): # pragma: no cover
regex = regex[0:-7]
elif regex.startswith(r'(?s:') and regex.endswith(r')\Z'): # pragma: no cover
regex = regex[4:-3]
# Finally, convert back to regex operating on bytestr
return regex.encode()
class PathQuoting:
_unescape = {b'a': b'\a',
b'b': b'\b',
b'f': b'\f',
b'n': b'\n',
b'r': b'\r',
b't': b'\t',
b'v': b'\v',
b'"': b'"',
b'\\':b'\\'}
_unescape_re = re.compile(br'\\([a-z"\\]|[0-9]{3})')
_escape = [bytes([x]) for x in range(127)]+[
b'\\'+bytes(ord(c) for c in oct(x)[2:]) for x in range(127,256)]
_reverse = dict(map(reversed, _unescape.items()))
for x in _reverse:
_escape[ord(x)] = b'\\'+_reverse[x]
_special_chars = [len(x) > 1 for x in _escape]
@staticmethod
def unescape_sequence(orig):
seq = orig.group(1)
return PathQuoting._unescape[seq] if len(seq) == 1 else bytes([int(seq, 8)])
@staticmethod
def dequote(quoted_string):
if quoted_string.startswith(b'"'):
assert quoted_string.endswith(b'"')
return PathQuoting._unescape_re.sub(PathQuoting.unescape_sequence,
quoted_string[1:-1])
return quoted_string
@staticmethod
def enquote(unquoted_string):
# Option 1: Quoting when fast-export would:
# pqsc = PathQuoting._special_chars
# if any(pqsc[x] for x in set(unquoted_string)):
# Option 2, perf hack: do minimal amount of quoting required by fast-import
if unquoted_string.startswith(b'"') or b'\n' in unquoted_string:
pqe = PathQuoting._escape
return b'"' + b''.join(pqe[x] for x in unquoted_string) + b'"'
return unquoted_string
class AncestryGraph(object):
"""
A class that maintains a direct acycle graph of commits for the purpose of
determining if one commit is the ancestor of another.
"""
def __init__(self):
self.cur_value = 0
# A mapping from the external identifers given to us to the simple integers
# we use in self.graph
self.value = {}
# A tuple of (depth, list-of-ancestors). Values and keys in this graph are
# all integers from the self.value dict. The depth of a commit is one more
# than the max depth of any of its ancestors.
self.graph = {}
# Cached results from previous calls to is_ancestor().
self._cached_is_ancestor = {}
def record_external_commits(self, external_commits):
"""
Record in graph that each commit in external_commits exists, and is
treated as a root commit with no parents.
"""
for c in external_commits:
if c not in self.value:
self.cur_value += 1
self.value[c] = self.cur_value
self.graph[self.cur_value] = (1, [])
def add_commit_and_parents(self, commit, parents):
"""
Record in graph that commit has the given parents. parents _MUST_ have
been first recorded. commit _MUST_ not have been recorded yet.
"""
assert all(p in self.value for p in parents)
assert commit not in self.value
# Get values for commit and parents
self.cur_value += 1
self.value[commit] = self.cur_value
graph_parents = [self.value[x] for x in parents]
# Determine depth for commit, then insert the info into the graph
depth = 1
if parents:
depth += max(self.graph[p][0] for p in graph_parents)
self.graph[self.cur_value] = (depth, graph_parents)
def is_ancestor(self, possible_ancestor, check):
"""
Return whether possible_ancestor is an ancestor of check
"""
a, b = self.value[possible_ancestor], self.value[check]
original_pair = (a,b)
a_depth = self.graph[a][0]
ancestors = [b]
visited = set()
while ancestors:
ancestor = ancestors.pop()
prev_pair = (a, ancestor)
if prev_pair in self._cached_is_ancestor:
if not self._cached_is_ancestor[prev_pair]:
continue
self._cached_is_ancestor[original_pair] = True
return True
if ancestor in visited:
continue
visited.add(ancestor)
depth, more_ancestors = self.graph[ancestor]
if ancestor == a:
self._cached_is_ancestor[original_pair] = True
return True
elif depth <= a_depth:
continue
ancestors.extend(more_ancestors)
self._cached_is_ancestor[original_pair] = False
return False
class MailmapInfo(object):
def __init__(self, filename):
self.changes = {}
self._parse_file(filename)
def _parse_file(self, filename):
name_and_email_re = re.compile(br'(.*?)\s*<([^>]*)>\s*')
comment_re = re.compile(br'\s*#.*')
if not os.access(filename, os.R_OK):
raise SystemExit(_("Cannot read %s") % decode(filename))
with open(filename, 'br') as f:
count = 0
for line in f:
count += 1
err = "Unparseable mailmap file: line #{} is bad: {}".format(count, line)
# Remove comments
line = comment_re.sub(b'', line)
# Remove leading and trailing whitespace
line = line.strip()
if not line:
continue
m = name_and_email_re.match(line)
if not m:
raise SystemExit(err)
proper_name, proper_email = m.groups()
if len(line) == m.end():
self.changes[(None, proper_email)] = (proper_name, proper_email)
continue
rest = line[m.end():]
m = name_and_email_re.match(rest)
if m:
commit_name, commit_email = m.groups()
if len(rest) != m.end():
raise SystemExit(err)
else:
commit_name, commit_email = rest, None
self.changes[(commit_name, commit_email)] = (proper_name, proper_email)
def translate(self, name, email):
''' Given a name and email, return the expected new name and email from the
mailmap if there is a translation rule for it, otherwise just return
the given name and email.'''
for old, new in self.changes.items():
old_name, old_email = old
new_name, new_email = new
if (old_email is None or email.lower() == old_email.lower()) and (
name == old_name or not old_name):
return (new_name or name, new_email or email)
return (name, email)
class ProgressWriter(object):
def __init__(self):
self._last_progress_update = time.time()
self._last_message = None
def show(self, msg):
self._last_message = msg
now = time.time()
if now - self._last_progress_update > .1:
self._last_progress_update = now
sys.stdout.write("\r{}".format(msg))
sys.stdout.flush()
def finish(self):
self._last_progress_update = 0
if self._last_message:
self.show(self._last_message)
sys.stdout.write("\n")
class _IDs(object):
"""
A class that maintains the 'name domain' of all the 'marks' (short int
id for a blob/commit git object). The reason this mechanism is necessary
is because the text of fast-export may refer to an object using a different
mark than the mark that was assigned to that object using IDS.new(). This
class allows you to translate the fast-export marks (old) to the marks
assigned from IDS.new() (new).
Note that there are two reasons why the marks may differ: (1) The
user manually creates Blob or Commit objects (for insertion into the
stream) (2) We're reading the data from two different repositories
and trying to combine the data (git fast-export will number ids from
1...n, and having two 1's, two 2's, two 3's, causes issues).
"""
def __init__(self):
"""
Init
"""
# The id for the next created blob/commit object
self._next_id = 1
# A map of old-ids to new-ids (1:1 map)
self._translation = {}
# A map of new-ids to every old-id that points to the new-id (1:N map)
self._reverse_translation = {}
def has_renames(self):
"""
Return whether there have been ids remapped to new values
"""
return bool(self._translation)
def new(self):
"""
Should be called whenever a new blob or commit object is created. The
returned value should be used as the id/mark for that object.
"""
rv = self._next_id
self._next_id += 1
return rv
def record_rename(self, old_id, new_id, handle_transitivity = False):
"""
Record that old_id is being renamed to new_id.
"""
if old_id != new_id:
# old_id -> new_id
self._translation[old_id] = new_id
# Transitivity will be needed if new commits are being inserted mid-way
# through a branch.
if handle_transitivity:
# Anything that points to old_id should point to new_id
if old_id in self._reverse_translation:
for id_ in self._reverse_translation[old_id]:
self._translation[id_] = new_id
# Record that new_id is pointed to by old_id
if new_id not in self._reverse_translation:
self._reverse_translation[new_id] = []
self._reverse_translation[new_id].append(old_id)
def translate(self, old_id):
"""
If old_id has been mapped to an alternate id, return the alternate id.
"""
if old_id in self._translation:
return self._translation[old_id]
else:
return old_id
def __str__(self):
"""
Convert IDs to string; used for debugging
"""
rv = "Current count: %d\nTranslation:\n" % self._next_id
for k in sorted(self._translation):
rv += " %d -> %s\n" % (k, self._translation[k])
rv += "Reverse translation:\n"
for k in sorted(self._reverse_translation):
rv += " " + str(k) + " -> " + str(self._reverse_translation[k]) + "\n"
return rv
class _GitElement(object):
"""
The base class for all git elements that we create.
"""
def __init__(self):
# A string that describes what type of Git element this is
self.type = None
# A flag telling us if this Git element has been dumped
# (i.e. printed) or skipped. Typically elements that have been
# dumped or skipped will not be dumped again.
self.dumped = 0
def dump(self, file_):
"""
This version should never be called. Derived classes need to
override! We should note that subclasses should implement this
method such that the output would match the format produced by
fast-export.
"""
raise SystemExit(_("Unimplemented function: %s") % type(self).__name__
+".dump()") # pragma: no cover
def __bytes__(self):
"""
Convert GitElement to bytestring; used for debugging
"""
old_dumped = self.dumped
writeme = io.BytesIO()
self.dump(writeme)
output_lines = writeme.getvalue().splitlines()
writeme.close()
self.dumped = old_dumped
return b"%s:\n %s" % (type(self).__name__.encode(),
b"\n ".join(output_lines))
def skip(self, new_id=None):
"""
Ensures this element will not be written to output
"""
self.dumped = 2
class _GitElementWithId(_GitElement):
"""
The base class for Git elements that have IDs (commits and blobs)
"""
def __init__(self):
_GitElement.__init__(self)
# The mark (short, portable id) for this element
self.id = _IDS.new()
# The previous mark for this element
self.old_id = None
def skip(self, new_id=None):
"""
This element will no longer be automatically written to output. When a
commit gets skipped, it's ID will need to be translated to that of its
parent.
"""
self.dumped = 2
_IDS.record_rename(self.old_id or self.id, new_id)
class Blob(_GitElementWithId):
"""
This class defines our representation of git blob elements (i.e. our
way of representing file contents).
"""
def __init__(self, data, original_id = None):
_GitElementWithId.__init__(self)
# Denote that this is a blob
self.type = 'blob'
# Record original id
self.original_id = original_id
# Stores the blob's data
assert(type(data) == bytes)
self.data = data
def dump(self, file_):
"""
Write this blob element to a file.
"""
self.dumped = 1
HASH_TO_ID[self.original_id] = self.id
ID_TO_HASH[self.id] = self.original_id
file_.write(b'blob\n')
file_.write(b'mark :%d\n' % self.id)
file_.write(b'data %d\n%s' % (len(self.data), self.data))
file_.write(b'\n')
class Reset(_GitElement):
"""
This class defines our representation of git reset elements. A reset
event is the creation (or recreation) of a named branch, optionally
starting from a specific revision).
"""
def __init__(self, ref, from_ref = None):
_GitElement.__init__(self)
# Denote that this is a reset
self.type = 'reset'
# The name of the branch being (re)created
self.ref = ref
# Some reference to the branch/commit we are resetting from
self.from_ref = from_ref
def dump(self, file_):
"""
Write this reset element to a file
"""
self.dumped = 1
file_.write(b'reset %s\n' % self.ref)
if self.from_ref:
if isinstance(self.from_ref, int):
file_.write(b'from :%d\n' % self.from_ref)
else:
file_.write(b'from %s\n' % self.from_ref)
file_.write(b'\n')
class FileChange(_GitElement):
"""
This class defines our representation of file change elements. File change
elements are components within a Commit element.
"""
def __init__(self, type_, filename = None, id_ = None, mode = None):
_GitElement.__init__(self)
# Denote the type of file-change (b'M' for modify, b'D' for delete, etc)
# We could
# assert(type(type_) == bytes)
# here but I don't just due to worries about performance overhead...
self.type = type_
# Record the name of the file being changed
self.filename = filename
# Record the mode (mode describes type of file entry (non-executable,
# executable, or symlink)).
self.mode = mode
# blob_id is the id (mark) of the affected blob
self.blob_id = id_
if type_ == b'DELETEALL':
assert filename is None and id_ is None and mode is None
self.filename = b'' # Just so PathQuoting.enquote doesn't die
else:
assert filename is not None
if type_ == b'M':
assert id_ is not None and mode is not None
elif type_ == b'D':
assert id_ is None and mode is None
elif type_ == b'R': # pragma: no cover (now avoid fast-export renames)
assert mode is None
if id_ is None:
raise SystemExit(_("new name needed for rename of %s") % filename)
self.filename = (self.filename, id_)
self.blob_id = None
def dump(self, file_):
"""
Write this file-change element to a file
"""
skipped_blob = (self.type == b'M' and self.blob_id is None)
if skipped_blob: return
self.dumped = 1
quoted_filename = PathQuoting.enquote(self.filename)
if self.type == b'M' and isinstance(self.blob_id, int):
file_.write(b'M %s :%d %s\n' % (self.mode, self.blob_id, quoted_filename))
elif self.type == b'M':
file_.write(b'M %s %s %s\n' % (self.mode, self.blob_id, quoted_filename))
elif self.type == b'D':
file_.write(b'D %s\n' % quoted_filename)
elif self.type == b'DELETEALL':
file_.write(b'deleteall\n')
else:
raise SystemExit(_("Unhandled filechange type: %s") % self.type) # pragma: no cover
class Commit(_GitElementWithId):
"""
This class defines our representation of commit elements. Commit elements
contain all the information associated with a commit.
"""
def __init__(self, branch,
author_name, author_email, author_date,
committer_name, committer_email, committer_date,
message,
file_changes,
parents,
original_id = None,
encoding = None, # encoding for message; None implies UTF-8
**kwargs):
_GitElementWithId.__init__(self)
self.old_id = self.id
# Denote that this is a commit element
self.type = 'commit'
# Record the affected branch
self.branch = branch
# Record original id
self.original_id = original_id
# Record author's name
self.author_name = author_name
# Record author's email
self.author_email = author_email
# Record date of authoring
self.author_date = author_date
# Record committer's name
self.committer_name = committer_name
# Record committer's email
self.committer_email = committer_email
# Record date the commit was made
self.committer_date = committer_date
# Record commit message and its encoding
self.encoding = encoding
self.message = message
# List of file-changes associated with this commit. Note that file-changes
# are also represented as git elements
self.file_changes = file_changes
self.parents = parents
def dump(self, file_):
"""
Write this commit element to a file.
"""
self.dumped = 1
HASH_TO_ID[self.original_id] = self.id
ID_TO_HASH[self.id] = self.original_id
# Make output to fast-import slightly easier for humans to read if the
# message has no trailing newline of its own; cosmetic, but a nice touch...
extra_newline = b'\n'
if self.message.endswith(b'\n') or not (self.parents or self.file_changes):
extra_newline = b''
if not self.parents:
file_.write(b'reset %s\n' % self.branch)
file_.write((b'commit %s\n'
b'mark :%d\n'
b'author %s <%s> %s\n'
b'committer %s <%s> %s\n'
) % (
self.branch, self.id,
self.author_name, self.author_email, self.author_date,
self.committer_name, self.committer_email, self.committer_date
))
if self.encoding:
file_.write(b'encoding %s\n' % self.encoding)
file_.write(b'data %d\n%s%s' %
(len(self.message), self.message, extra_newline))
for i, parent in enumerate(self.parents):
file_.write(b'from ' if i==0 else b'merge ')
if isinstance(parent, int):
file_.write(b':%d\n' % parent)
else:
file_.write(b'%s\n' % parent)
for change in self.file_changes:
change.dump(file_)
if not self.parents and not self.file_changes:
# Workaround a bug in pre-git-2.22 versions of fast-import with
# the get-mark directive.
file_.write(b'\n')
file_.write(b'\n')
def first_parent(self):
"""
Return first parent commit
"""
if self.parents:
return self.parents[0]
return None
def skip(self, new_id=None):
_SKIPPED_COMMITS.add(self.old_id or self.id)
_GitElementWithId.skip(self, new_id)
class Tag(_GitElementWithId):
"""
This class defines our representation of annotated tag elements.
"""
def __init__(self, ref, from_ref,
tagger_name, tagger_email, tagger_date, tag_msg,
original_id = None):
_GitElementWithId.__init__(self)
self.old_id = self.id
# Denote that this is a tag element
self.type = 'tag'
# Store the name of the tag
self.ref = ref
# Store the entity being tagged (this should be a commit)
self.from_ref = from_ref
# Record original id
self.original_id = original_id
# Store the name of the tagger
self.tagger_name = tagger_name
# Store the email of the tagger
self.tagger_email = tagger_email
# Store the date
self.tagger_date = tagger_date
# Store the tag message
self.message = tag_msg
def dump(self, file_):
"""
Write this tag element to a file
"""
self.dumped = 1
HASH_TO_ID[self.original_id] = self.id
ID_TO_HASH[self.id] = self.original_id
file_.write(b'tag %s\n' % self.ref)
if (write_marks and self.id):
file_.write(b'mark :%d\n' % self.id)
markfmt = b'from :%d\n' if isinstance(self.from_ref, int) else b'from %s\n'
file_.write(markfmt % self.from_ref)
if self.tagger_name:
file_.write(b'tagger %s <%s> ' % (self.tagger_name, self.tagger_email))
file_.write(self.tagger_date)
file_.write(b'\n')
file_.write(b'data %d\n%s' % (len(self.message), self.message))
file_.write(b'\n')
class Progress(_GitElement):
"""
This class defines our representation of progress elements. The progress
element only contains a progress message, which is printed by fast-import
when it processes the progress output.
"""
def __init__(self, message):
_GitElement.__init__(self)
# Denote that this is a progress element
self.type = 'progress'
# Store the progress message
self.message = message
def dump(self, file_):
"""
Write this progress element to a file
"""
self.dumped = 1
file_.write(b'progress %s\n' % self.message)
file_.write(b'\n')
class Checkpoint(_GitElement):
"""
This class defines our representation of checkpoint elements. These
elements represent events which force fast-import to close the current
packfile, start a new one, and to save out all current branch refs, tags
and marks.
"""
def __init__(self):
_GitElement.__init__(self)
# Denote that this is a checkpoint element
self.type = 'checkpoint'
def dump(self, file_):
"""
Write this checkpoint element to a file
"""
self.dumped = 1
file_.write(b'checkpoint\n')
file_.write(b'\n')
class LiteralCommand(_GitElement):
"""
This class defines our representation of commands. The literal command
includes only a single line, and is not processed in any special way.
"""
def __init__(self, line):
_GitElement.__init__(self)
# Denote that this is a literal element
self.type = 'literal'
# Store the command
self.line = line
def dump(self, file_):
"""
Write this progress element to a file
"""
self.dumped = 1
file_.write(self.line)
class Alias(_GitElement):
"""
This class defines our representation of fast-import alias elements. An
alias element is the setting of one mark to the same sha1sum as another,
usually because the newer mark corresponded to a pruned commit.
"""
def __init__(self, ref, to_ref):
_GitElement.__init__(self)
# Denote that this is a reset
self.type = 'alias'
self.ref = ref
self.to_ref = to_ref
def dump(self, file_):
"""
Write this reset element to a file
"""
self.dumped = 1
file_.write(b'alias\nmark :%d\nto :%d\n\n' % (self.ref, self.to_ref))
class FastExportParser(object):
"""
A class for parsing and handling the output from fast-export. This
class allows the user to register callbacks when various types of
data are encountered in the fast-export output. The basic idea is that,
FastExportParser takes fast-export output, creates the various objects
as it encounters them, the user gets to use/modify these objects via
callbacks, and finally FastExportParser outputs the modified objects
in fast-import format (presumably so they can be used to create a new
repo).
"""
def __init__(self,
tag_callback = None, commit_callback = None,
blob_callback = None, progress_callback = None,
reset_callback = None, checkpoint_callback = None,
done_callback = None):
# Members below simply store callback functions for the various git
# elements
self._tag_callback = tag_callback
self._blob_callback = blob_callback
self._reset_callback = reset_callback
self._commit_callback = commit_callback
self._progress_callback = progress_callback
self._checkpoint_callback = checkpoint_callback
self._done_callback = done_callback
# Keep track of which refs appear from the export, and which make it to
# the import (pruning of empty commits, renaming of refs, and creating
# new manual objects and inserting them can cause these to differ).
self._exported_refs = set()
self._imported_refs = set()
# A list of the branches we've seen, plus the last known commit they
# pointed to. An entry in latest_*commit will be deleted if we get a
# reset for that branch. These are used because of fast-import's weird
# decision to allow having an implicit parent via naming the branch
# instead of requiring branches to be specified via 'from' directives.
self._latest_commit = {}
self._latest_orig_commit = {}
# A handle to the input source for the fast-export data
self._input = None
# A handle to the output file for the output we generate (we call dump
# on many of the git elements we create).
self._output = None
# Stores the contents of the current line of input being parsed
self._currentline = ''
# Compile some regexes and cache those
self._mark_re = re.compile(br'mark :(\d+)\n$')
self._parent_regexes = {}
parent_regex_rules = (br' :(\d+)\n$', br' ([0-9a-f]{40})\n')
for parent_refname in (b'from', b'merge'):
ans = [re.compile(parent_refname+x) for x in parent_regex_rules]
self._parent_regexes[parent_refname] = ans
self._quoted_string_re = re.compile(br'"(?:[^"\\]|\\.)*"')
self._refline_regexes = {}
for refline_name in (b'reset', b'commit', b'tag', b'progress'):
self._refline_regexes[refline_name] = re.compile(refline_name+b' (.*)\n$')
self._user_regexes = {}
for user in (b'author', b'committer', b'tagger'):
self._user_regexes[user] = re.compile(user + b' (.*?) <(.*?)> (.*)\n$')
def _advance_currentline(self):
"""
Grab the next line of input
"""
self._currentline = self._input.readline()
def _parse_optional_mark(self):
"""
If the current line contains a mark, parse it and advance to the
next line; return None otherwise
"""
mark = None
matches = self._mark_re.match(self._currentline)
if matches:
mark = int(matches.group(1))
self._advance_currentline()
return mark
def _parse_optional_parent_ref(self, refname):
"""
If the current line contains a reference to a parent commit, then
parse it and advance the current line; otherwise return None. Note
that the name of the reference ('from', 'merge') must match the
refname arg.
"""
orig_baseref, baseref = None, None
rule, altrule = self._parent_regexes[refname]
matches = rule.match(self._currentline)
if matches:
orig_baseref = int(matches.group(1))
# We translate the parent commit mark to what it needs to be in
# our mark namespace
baseref = _IDS.translate(orig_baseref)
self._advance_currentline()
else:
matches = altrule.match(self._currentline)
if matches:
orig_baseref = matches.group(1)
baseref = orig_baseref
self._advance_currentline()
return orig_baseref, baseref
def _parse_optional_filechange(self):
"""
If the current line contains a file-change object, then parse it
and advance the current line; otherwise return None. We only care
about file changes of type b'M' and b'D' (these are the only types
of file-changes that fast-export will provide).
"""
filechange = None
changetype = self._currentline[0:1]
if changetype == b'M':
(changetype, mode, idnum, path) = self._currentline.split(None, 3)
if idnum[0:1] == b':':
idnum = idnum[1:]
path = path.rstrip(b'\n')
# We translate the idnum to our id system
if len(idnum) != 40:
idnum = _IDS.translate( int(idnum) )
if idnum is not None:
if path.startswith(b'"'):
path = PathQuoting.dequote(path)
filechange = FileChange(b'M', path, idnum, mode)
else:
filechange = b'skipped'
self._advance_currentline()
elif changetype == b'D':
(changetype, path) = self._currentline.split(None, 1)
path = path.rstrip(b'\n')
if path.startswith(b'"'):
path = PathQuoting.dequote(path)
filechange = FileChange(b'D', path)
self._advance_currentline()
elif changetype == b'R': # pragma: no cover (now avoid fast-export renames)
rest = self._currentline[2:-1]
if rest.startswith(b'"'):
m = self._quoted_string_re.match(rest)
if not m:
raise SystemExit(_("Couldn't parse rename source"))
orig = PathQuoting.dequote(m.group(0))
new = rest[m.end()+1:]
else:
orig, new = rest.split(b' ', 1)
if new.startswith(b'"'):
new = PathQuoting.dequote(new)
filechange = FileChange(b'R', orig, new)
self._advance_currentline()
return filechange
def _parse_original_id(self):
original_id = self._currentline[len(b'original-oid '):].rstrip()
self._advance_currentline()
return original_id
def _parse_encoding(self):
encoding = self._currentline[len(b'encoding '):].rstrip()
self._advance_currentline()
return encoding
def _parse_ref_line(self, refname):
"""
Parses string data (often a branch name) from current-line. The name of
the string data must match the refname arg. The program will crash if
current-line does not match, so current-line will always be advanced if
this method returns.
"""
matches = self._refline_regexes[refname].match(self._currentline)
if not matches:
raise SystemExit(_("Malformed %(refname)s line: '%(line)s'") %
({'refname': refname, 'line':self._currentline})
) # pragma: no cover
ref = matches.group(1)
self._advance_currentline()
return ref
def _parse_user(self, usertype):
"""
Get user name, email, datestamp from current-line. Current-line will
be advanced.
"""
user_regex = self._user_regexes[usertype]
(name, email, when) = user_regex.match(self._currentline).groups()
self._advance_currentline()
return (name, email, when)
def _parse_data(self):
"""
Reads data from _input. Current-line will be advanced until it is beyond
the data.
"""
fields = self._currentline.split()
assert fields[0] == b'data'
size = int(fields[1])
data = self._input.read(size)
self._advance_currentline()
if self._currentline == b'\n':
self._advance_currentline()
return data
def _parse_blob(self):
"""
Parse input data into a Blob object. Once the Blob has been created, it
will be handed off to the appropriate callbacks. Current-line will be
advanced until it is beyond this blob's data. The Blob will be dumped
to _output once everything else is done (unless it has been skipped by
the callback).
"""
# Parse the Blob
self._advance_currentline()
id_ = self._parse_optional_mark()
original_id = None
if self._currentline.startswith(b'original-oid'):
original_id = self._parse_original_id();
data = self._parse_data()
if self._currentline == b'\n':
self._advance_currentline()
# Create the blob
blob = Blob(data, original_id)
# If fast-export text had a mark for this blob, need to make sure this
# mark translates to the blob's true id.
if id_:
blob.old_id = id_
_IDS.record_rename(id_, blob.id)
# Call any user callback to allow them to use/modify the blob
if self._blob_callback:
self._blob_callback(blob)
# Now print the resulting blob
if not blob.dumped:
blob.dump(self._output)
def _parse_reset(self):
"""
Parse input data into a Reset object. Once the Reset has been created,
it will be handed off to the appropriate callbacks. Current-line will
be advanced until it is beyond the reset data. The Reset will be dumped
to _output once everything else is done (unless it has been skipped by
the callback).
"""
# Parse the Reset
ref = self._parse_ref_line(b'reset')
self._exported_refs.add(ref)
ignoreme, from_ref = self._parse_optional_parent_ref(b'from')
if self._currentline == b'\n':
self._advance_currentline()
# fast-export likes to print extraneous resets that serve no purpose.
# While we could continue processing such resets, that is a waste of
# resources. Also, we want to avoid recording that this ref was
# seen in such cases, since this ref could be rewritten to nothing.
if not from_ref:
self._latest_commit.pop(ref, None)
self._latest_orig_commit.pop(ref, None)
return
# Create the reset
reset = Reset(ref, from_ref)
# Call any user callback to allow them to modify the reset
if self._reset_callback:
self._reset_callback(reset)
# Update metadata
self._latest_commit[reset.ref] = reset.from_ref
self._latest_orig_commit[reset.ref] = reset.from_ref
# Now print the resulting reset
if not reset.dumped:
self._imported_refs.add(reset.ref)
reset.dump(self._output)
def _parse_commit(self):
"""
Parse input data into a Commit object. Once the Commit has been created,
it will be handed off to the appropriate callbacks. Current-line will
be advanced until it is beyond the commit data. The Commit will be dumped
to _output once everything else is done (unless it has been skipped by
the callback OR the callback has removed all file-changes from the commit).
"""
# Parse the Commit. This may look involved, but it's pretty simple; it only
# looks bad because a commit object contains many pieces of data.
branch = self._parse_ref_line(b'commit')
self._exported_refs.add(branch)
id_ = self._parse_optional_mark()
original_id = None
if self._currentline.startswith(b'original-oid'):
original_id = self._parse_original_id();
author_name = None
author_email = None
if self._currentline.startswith(b'author'):
(author_name, author_email, author_date) = self._parse_user(b'author')
(committer_name, committer_email, committer_date) = \
self._parse_user(b'committer')
if not author_name and not author_email:
(author_name, author_email, author_date) = \
(committer_name, committer_email, committer_date)
encoding = None
if self._currentline.startswith(b'encoding '):
encoding = self._parse_encoding()
commit_msg = self._parse_data()
pinfo = [self._parse_optional_parent_ref(b'from')]
# Due to empty pruning, we can have real 'from' and 'merge' lines that
# due to commit rewriting map to a parent of None. We need to record
# 'from' if its non-None, and we need to parse all 'merge' lines.
while self._currentline.startswith(b'merge '):
pinfo.append(self._parse_optional_parent_ref(b'merge'))
orig_parents, parents = [list(tmp) for tmp in zip(*pinfo)]
# No parents is oddly represented as [None] instead of [], due to the
# special 'from' handling. Convert it here to a more canonical form.
if parents == [None]:
parents = []
if orig_parents == [None]:
orig_parents = []
# fast-import format is kinda stupid in that it allows implicit parents
# based on the branch name instead of requiring them to be specified by
# 'from' directives. The only way to get no parent is by using a reset
# directive first, which clears the latest_commit_for_this_branch tracking.
if not orig_parents and self._latest_commit.get(branch):
parents = [self._latest_commit[branch]]
if not orig_parents and self._latest_orig_commit.get(branch):
orig_parents = [self._latest_orig_commit[branch]]
# Get the list of file changes
file_changes = []
file_change = self._parse_optional_filechange()
had_file_changes = file_change is not None
while file_change:
if not (type(file_change) == bytes and file_change == b'skipped'):
file_changes.append(file_change)
file_change = self._parse_optional_filechange()
if self._currentline == b'\n':
self._advance_currentline()
# Okay, now we can finally create the Commit object
commit = Commit(branch,
author_name, author_email, author_date,
committer_name, committer_email, committer_date,
commit_msg, file_changes, parents, original_id, encoding)
# If fast-export text had a mark for this commit, need to make sure this
# mark translates to the commit's true id.
if id_:
commit.old_id = id_
_IDS.record_rename(id_, commit.id)
# Call any user callback to allow them to modify the commit
aux_info = {'orig_parents': orig_parents,
'had_file_changes': had_file_changes}
if self._commit_callback:
self._commit_callback(commit, aux_info)
# Now print the resulting commit, or if prunable skip it
self._latest_orig_commit[branch] = commit.id
if not (commit.old_id or commit.id) in _SKIPPED_COMMITS:
self._latest_commit[branch] = commit.id
if not commit.dumped:
self._imported_refs.add(commit.branch)
commit.dump(self._output)
def _parse_tag(self):
"""
Parse input data into a Tag object. Once the Tag has been created,
it will be handed off to the appropriate callbacks. Current-line will
be advanced until it is beyond the tag data. The Tag will be dumped
to _output once everything else is done (unless it has been skipped by
the callback).
"""
# Parse the Tag
tag = self._parse_ref_line(b'tag')
self._exported_refs.add(b'refs/tags/'+tag)
id_ = self._parse_optional_mark()
ignoreme, from_ref = self._parse_optional_parent_ref(b'from')
original_id = None
if self._currentline.startswith(b'original-oid'):
original_id = self._parse_original_id();
tagger_name, tagger_email, tagger_date = None, None, None
if self._currentline.startswith(b'tagger'):
(tagger_name, tagger_email, tagger_date) = self._parse_user(b'tagger')
tag_msg = self._parse_data()
if self._currentline == b'\n':
self._advance_currentline()
# Create the tag
tag = Tag(tag, from_ref,
tagger_name, tagger_email, tagger_date, tag_msg,
original_id)
# If fast-export text had a mark for this tag, need to make sure this
# mark translates to the tag's true id.
if id_:
tag.old_id = id_
_IDS.record_rename(id_, tag.id)
# Call any user callback to allow them to modify the tag
if self._tag_callback:
self._tag_callback(tag)
# The tag might not point at anything that still exists (self.from_ref
# will be None if the commit it pointed to and all its ancestors were
# pruned due to being empty)
if tag.from_ref:
# Print out this tag's information
if not tag.dumped:
self._imported_refs.add(b'refs/tags/'+tag.ref)
tag.dump(self._output)
else:
tag.skip()
def _parse_progress(self):
"""
Parse input data into a Progress object. Once the Progress has
been created, it will be handed off to the appropriate
callbacks. Current-line will be advanced until it is beyond the
progress data. The Progress will be dumped to _output once
everything else is done (unless it has been skipped by the callback).
"""
# Parse the Progress
message = self._parse_ref_line(b'progress')
if self._currentline == b'\n':
self._advance_currentline()
# Create the progress message
progress = Progress(message)
# Call any user callback to allow them to modify the progress messsage
if self._progress_callback:
self._progress_callback(progress)
# NOTE: By default, we do NOT print the progress message; git
# fast-import would write it to fast_import_pipes which could mess with
# our parsing of output from the 'ls' and 'get-mark' directives we send
# to fast-import. If users want these messages, they need to process
# and handle them in the appropriate callback above.
def _parse_checkpoint(self):
"""
Parse input data into a Checkpoint object. Once the Checkpoint has
been created, it will be handed off to the appropriate
callbacks. Current-line will be advanced until it is beyond the
checkpoint data. The Checkpoint will be dumped to _output once
everything else is done (unless it has been skipped by the callback).
"""
# Parse the Checkpoint
self._advance_currentline()
if self._currentline == b'\n':
self._advance_currentline()
# Create the checkpoint
checkpoint = Checkpoint()
# Call any user callback to allow them to drop the checkpoint
if self._checkpoint_callback:
self._checkpoint_callback(checkpoint)
# NOTE: By default, we do NOT print the checkpoint message; although it
# we would only realistically get them with --stdin, the fact that we
# are filtering makes me think the checkpointing is less likely to be
# reasonable. In fact, I don't think it's necessary in general. If
# users do want it, they should process it in the checkpoint_callback.
def _parse_literal_command(self):
"""
Parse literal command. Then just dump the line as is.
"""
# Create the literal command object
command = LiteralCommand(self._currentline)
self._advance_currentline()
# Now print the resulting literal command
if not command.dumped:
command.dump(self._output)
def insert(self, obj):
assert not obj.dumped
obj.dump(self._output)
if type(obj) == Commit:
self._imported_refs.add(obj.branch)
elif type(obj) in (Reset, Tag):
self._imported_refs.add(obj.ref)
def run(self, input, output):
"""
This method filters fast export output.
"""
# Set input. If no args provided, use stdin.
self._input = input
self._output = output
# Run over the input and do the filtering
self._advance_currentline()
while self._currentline:
if self._currentline.startswith(b'blob'):
self._parse_blob()
elif self._currentline.startswith(b'reset'):
self._parse_reset()
elif self._currentline.startswith(b'commit'):
self._parse_commit()
elif self._currentline.startswith(b'tag'):
self._parse_tag()
elif self._currentline.startswith(b'progress'):
self._parse_progress()
elif self._currentline.startswith(b'checkpoint'):
self._parse_checkpoint()
elif self._currentline.startswith(b'feature'):
self._parse_literal_command()
elif self._currentline.startswith(b'option'):
self._parse_literal_command()
elif self._currentline.startswith(b'done'):
if self._done_callback:
self._done_callback()
self._parse_literal_command()
# Prevent confusion from others writing additional stuff that'll just
# be ignored
self._output.close()
elif self._currentline.startswith(b'#'):
self._parse_literal_command()
elif self._currentline.startswith(b'get-mark') or \
self._currentline.startswith(b'cat-blob') or \
self._currentline.startswith(b'ls'):
raise SystemExit(_("Unsupported command: '%s'") % self._currentline)
else:
raise SystemExit(_("Could not parse line: '%s'") % self._currentline)
def get_exported_and_imported_refs(self):
return self._exported_refs, self._imported_refs
def record_id_rename(old_id, new_id):
"""
Register a new translation
"""
handle_transitivity = True
_IDS.record_rename(old_id, new_id, handle_transitivity)
# Internal globals
_IDS = _IDs()
_SKIPPED_COMMITS = set()
HASH_TO_ID = {}
ID_TO_HASH = {}
class SubprocessWrapper(object):
@staticmethod
def decodify(args):
if type(args) == str:
return args
else:
assert type(args) == list
return [decode(x) if type(x)==bytes else x for x in args]
@staticmethod
def call(*args, **kwargs):
if 'cwd' in kwargs:
kwargs['cwd'] = decode(kwargs['cwd'])
return subprocess.call(SubprocessWrapper.decodify(*args), **kwargs)
@staticmethod
def check_output(*args, **kwargs):
if 'cwd' in kwargs:
kwargs['cwd'] = decode(kwargs['cwd'])
return subprocess.check_output(SubprocessWrapper.decodify(*args), **kwargs)
@staticmethod
def check_call(*args, **kwargs): # pragma: no cover # used by filter-lamely
if 'cwd' in kwargs:
kwargs['cwd'] = decode(kwargs['cwd'])
return subprocess.check_call(SubprocessWrapper.decodify(*args), **kwargs)
@staticmethod
def Popen(*args, **kwargs):
if 'cwd' in kwargs:
kwargs['cwd'] = decode(kwargs['cwd'])
return subprocess.Popen(SubprocessWrapper.decodify(*args), **kwargs)
subproc = subprocess
if platform.system() == 'Windows' or 'PRETEND_UNICODE_ARGS' in os.environ:
subproc = SubprocessWrapper
class GitUtils(object):
@staticmethod
def get_commit_count(repo, *args):
"""
Return the number of commits that have been made on repo.
"""
if not args:
args = ['--all']
if len(args) == 1 and isinstance(args[0], list):
args = args[0]
p = subproc.Popen(["git", "rev-list", "--count"] + args,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
cwd=repo)
if p.wait() != 0:
raise SystemExit(_("%s does not appear to be a valid git repository")
% decode(repo))
return int(p.stdout.read())
@staticmethod
def get_total_objects(repo):
"""
Return the number of objects (both packed and unpacked)
"""
p1 = subproc.Popen(["git", "count-objects", "-v"],
stdout=subprocess.PIPE, cwd=repo)
lines = p1.stdout.read().splitlines()
# Return unpacked objects + packed-objects
return int(lines[0].split()[1]) + int(lines[2].split()[1])
@staticmethod
def is_repository_bare(repo_working_dir):
out = subproc.check_output('git rev-parse --is-bare-repository'.split(),
cwd=repo_working_dir)
return (out.strip() == b'true')
@staticmethod
def determine_git_dir(repo_working_dir):
d = subproc.check_output('git rev-parse --git-dir'.split(),
cwd=repo_working_dir).strip()
if repo_working_dir==b'.' or d.startswith(b'/'):
return d
return os.path.join(repo_working_dir, d)
@staticmethod
def get_refs(repo_working_dir):
try:
output = subproc.check_output('git show-ref'.split(),
cwd=repo_working_dir)
except subprocess.CalledProcessError as e:
# If error code is 1, there just aren't any refs; i.e. new repo.
# If error code is other than 1, some other error (e.g. not a git repo)
if e.returncode != 1:
raise SystemExit('fatal: {}'.format(e))
output = ''
return dict(reversed(x.split()) for x in output.splitlines())
@staticmethod
def get_blob_sizes(quiet = False):
blob_size_progress = ProgressWriter()
num_blobs = 0
processed_blobs_msg = _("Processed %d blob sizes")
# Get sizes of blobs by sha1
cmd = '--batch-check=%(objectname) %(objecttype) ' + \
'%(objectsize) %(objectsize:disk)'
cf = subproc.Popen(['git', 'cat-file', '--batch-all-objects', cmd],
bufsize = -1,
stdout = subprocess.PIPE)
unpacked_size = {}
packed_size = {}
for line in cf.stdout:
sha, objtype, objsize, objdisksize = line.split()
objsize, objdisksize = int(objsize), int(objdisksize)
if objtype == b'blob':
unpacked_size[sha] = objsize
packed_size[sha] = objdisksize
num_blobs += 1
if not quiet:
blob_size_progress.show(processed_blobs_msg % num_blobs)
cf.wait()
if not quiet:
blob_size_progress.finish()
return unpacked_size, packed_size
@staticmethod
def get_file_changes(repo, parent_hash, commit_hash):
"""
Return a FileChanges list with the differences between parent_hash
and commit_hash
"""
file_changes = []
cmd = ["git", "diff-tree", "-r", parent_hash, commit_hash]
output = subproc.check_output(cmd, cwd=repo)
for line in output.splitlines():
fileinfo, path = line.split(b'\t', 1)
if path.startswith(b'"'):
path = PathQuoting.dequote(path)
oldmode, mode, oldhash, newhash, changetype = fileinfo.split()
if changetype == b'D':
file_changes.append(FileChange(b'D', path))
elif changetype in (b'A', b'M', b'T'):
identifier = HASH_TO_ID.get(newhash, newhash)
file_changes.append(FileChange(b'M', path, identifier, mode))
else: # pragma: no cover
raise SystemExit("Unknown change type for line {}".format(line))
return file_changes
@staticmethod
def print_my_version():
with open(__file__, 'br') as f:
contents = f.read()
# If people replaced @@LOCALEDIR@@ string to point at their local
# directory, undo it so we can get original source version.
contents = re.sub(br'\A#\!.*',
br'#!/usr/bin/env python3', contents)
contents = re.sub(br'(\("GIT_TEXTDOMAINDIR"\) or ").*"',
br'\1@@LOCALEDIR@@"', contents)
cmd = 'git hash-object --stdin'.split()
version = subproc.check_output(cmd, input=contents).strip()
print(decode(version[0:12]))
class FilteringOptions(object):
default_replace_text = b'***REMOVED***'
class AppendFilter(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
user_path = values
suffix = option_string[len('--path-'):] or 'match'
if suffix.startswith('rename'):
mod_type = 'rename'
match_type = option_string[len('--path-rename-'):] or 'match'
values = values.split(b':')
if len(values) != 2:
raise SystemExit(_("Error: --path-rename expects one colon in its"
" argument: <old_name:new_name>."))
if values[0] and values[1] and not (
values[0].endswith(b'/') == values[1].endswith(b'/')):
raise SystemExit(_("Error: With --path-rename, if OLD_NAME and "
"NEW_NAME are both non-empty and either ends "
"with a slash then both must."))
if any(v.startswith(b'/') for v in values):
raise SystemExit(_("Error: Pathnames cannot begin with a '/'"))
components = values[0].split(b'/') + values[1].split(b'/')
else:
mod_type = 'filter'
match_type = suffix
components = values.split(b'/')
if values.startswith(b'/'):
raise SystemExit(_("Error: Pathnames cannot begin with a '/'"))
for illegal_path in [b'.', b'..']:
if illegal_path in components:
raise SystemExit(_("Error: Invalid path component '%s' found in '%s'")
% (decode(illegal_path), decode(user_path)))
if match_type == 'regex':
values = re.compile(values)
items = getattr(namespace, self.dest, []) or []
items.append((mod_type, match_type, values))
if (match_type, mod_type) == ('glob', 'filter'):
if not values.endswith(b'*'):
extension = b'*' if values.endswith(b'/') else b'/*'
items.append((mod_type, match_type, values+extension))
setattr(namespace, self.dest, items)
class HelperFilter(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
af = FilteringOptions.AppendFilter(dest='path_changes',
option_strings=None)
dirname = values if values[-1:] == b'/' else values+b'/'
if option_string == '--subdirectory-filter':
af(parser, namespace, dirname, '--path-match')
af(parser, namespace, dirname+b':', '--path-rename')
elif option_string == '--to-subdirectory-filter':
af(parser, namespace, b':'+dirname, '--path-rename')
else:
raise SystemExit(_("Error: HelperFilter given invalid option_string: %s")
% option_string) # pragma: no cover
class FileWithPathsFilter(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
if not namespace.path_changes:
namespace.path_changes = []
namespace.path_changes += FilteringOptions.get_paths_from_file(values)
@staticmethod
def create_arg_parser():
# Include usage in the summary, so we can put the description first
summary = _('''Rewrite (or analyze) repository history
git-filter-repo destructively rewrites history (unless --analyze or
--dry-run are given) according to specified rules. It refuses to do any
rewriting unless either run from a clean fresh clone, or --force was
given.
Basic Usage:
git-filter-repo --analyze
git-filter-repo [FILTER/RENAME/CONTROL OPTIONS]
See EXAMPLES section for details.
''').rstrip()
# Provide a long helpful examples section
example_text = _('''CALLBACKS
All callback functions are of the same general format. For a command line
argument like
--foo-callback 'BODY'
the following code will be compiled and called:
def foo_callback(foo):
BODY
Thus, to replace 'Jon' with 'John' in author/committer/tagger names:
git filter-repo --name-callback 'return name.replace(b"Jon", b"John")'
To remove all 'Tested-by' tags in commit (or tag) messages:
git filter-repo --message-callback 'return re.sub(br"\\nTested-by:.*", "", message)'
To remove all .DS_Store files:
git filter-repo --filename-callback 'return None if os.path.basename(filename) == b".DS_Store" else filename'
Note that if BODY resolves to a filename, then the contents of that file
will be used as the BODY in the callback function.
For more detailed examples and explanations AND caveats, see
https://htmlpreview.github.io/?https://github.com/newren/git-filter-repo/blob/docs/html/git-filter-repo.html#CALLBACKS
EXAMPLES
To get a bunch of reports mentioning renames that have occurred in
your repo and listing sizes of objects aggregated by any of path,
directory, extension, or blob-id:
git filter-repo --analyze
(These reports can help you choose how to filter your repo; it can
be useful to re-run this command after filtering to regenerate the
report and verify the changes look correct.)
To extract the history that touched just 'guides' and 'tools/releases':
git filter-repo --path guides/ --path tools/releases
To remove foo.zip and bar/baz/zips from every revision in history:
git filter-repo --path foo.zip --path bar/baz/zips/ --invert-paths
To replace the text 'password' with 'p455w0rd':
git filter-repo --replace-text <(echo "password==>p455w0rd")
To use the current version of the .mailmap file to update authors,
committers, and taggers throughout history and make it permanent:
git filter-repo --use-mailmap
To extract the history of 'src/', rename all files to have a new leading
directory 'my-module' (e.g. src/foo.java -> my-module/src/foo.java), and
add a 'my-module-' prefix to all tags:
git filter-repo --path src/ --to-subdirectory-filter my-module --tag-rename '':'my-module-'
For more detailed examples and explanations, see
https://htmlpreview.github.io/?https://github.com/newren/git-filter-repo/blob/docs/html/git-filter-repo.html#EXAMPLES''')
# Create the basic parser
parser = argparse.ArgumentParser(description=summary,
usage = argparse.SUPPRESS,
add_help = False,
epilog = example_text,
formatter_class=argparse.RawDescriptionHelpFormatter)
analyze = parser.add_argument_group(title=_("Analysis"))
analyze.add_argument('--analyze', action='store_true',
help=_("Analyze repository history and create a report that may be "
"useful in determining what to filter in a subsequent run. "
"Will not modify your repo."))
analyze.add_argument('--report-dir',
metavar='DIR_OR_FILE',
type=os.fsencode,
dest='report_dir',
help=_("Directory to write report, defaults to GIT_DIR/filter_repo/analysis,"
"refuses to run if exists, --force delete existing dir first."))
path = parser.add_argument_group(title=_("Filtering based on paths "
"(see also --filename-callback)"),
description=textwrap.dedent(_("""
These options specify the paths to select. Note that much like git
itself, renames are NOT followed so you may need to specify multiple
paths, e.g. `--path olddir/ --path newdir/`
"""[1:])))
path.add_argument('--invert-paths', action='store_false', dest='inclusive',
help=_("Invert the selection of files from the specified "
"--path-{match,glob,regex} options below, i.e. only select "
"files matching none of those options."))
path.add_argument('--path-match', '--path', metavar='DIR_OR_FILE',
type=os.fsencode,
action=FilteringOptions.AppendFilter, dest='path_changes',
help=_("Exact paths (files or directories) to include in filtered "
"history. Multiple --path options can be specified to get "
"a union of paths."))
path.add_argument('--path-glob', metavar='GLOB', type=os.fsencode,
action=FilteringOptions.AppendFilter, dest='path_changes',
help=_("Glob of paths to include in filtered history. Multiple "
"--path-glob options can be specified to get a union of "
"paths."))
path.add_argument('--path-regex', metavar='REGEX', type=os.fsencode,
action=FilteringOptions.AppendFilter, dest='path_changes',
help=_("Regex of paths to include in filtered history. Multiple "
"--path-regex options can be specified to get a union of "
"paths"))
path.add_argument('--use-base-name', action='store_true',
help=_("Match on file base name instead of full path from the top "
"of the repo. Incompatible with --path-rename, and "
"incompatible with matching against directory names."))
rename = parser.add_argument_group(title=_("Renaming based on paths "
"(see also --filename-callback)"))
rename.add_argument('--path-rename', '--path-rename-match',
metavar='OLD_NAME:NEW_NAME', dest='path_changes', type=os.fsencode,
action=FilteringOptions.AppendFilter,
help=_("Path to rename; if filename or directory matches OLD_NAME "
"rename to NEW_NAME. Multiple --path-rename options can be "
"specified. NOTE: If you combine filtering options with "
"renaming ones, do not rely on a rename argument to select "
"paths; you also need a filter to select them."))
helpers = parser.add_argument_group(title=_("Path shortcuts"))
helpers.add_argument('--paths-from-file', metavar='FILENAME',
type=os.fsencode,
action=FilteringOptions.FileWithPathsFilter, dest='path_changes',
help=_("Specify several path filtering and renaming directives, one "
"per line. Lines with '==>' in them specify path renames, "
"and lines can begin with 'literal:' (the default), 'glob:', "
"or 'regex:' to specify different matching styles. Blank "
"lines and lines starting with a '#' are ignored."))
helpers.add_argument('--subdirectory-filter', metavar='DIRECTORY',
action=FilteringOptions.HelperFilter, type=os.fsencode,
help=_("Only look at history that touches the given subdirectory "
"and treat that directory as the project root. Equivalent "
"to using '--path DIRECTORY/ --path-rename DIRECTORY/:'"))
helpers.add_argument('--to-subdirectory-filter', metavar='DIRECTORY',
action=FilteringOptions.HelperFilter, type=os.fsencode,
help=_("Treat the project root as instead being under DIRECTORY. "
"Equivalent to using '--path-rename :DIRECTORY/'"))
contents = parser.add_argument_group(title=_("Content editing filters "
"(see also --blob-callback)"))
contents.add_argument('--replace-text', metavar='EXPRESSIONS_FILE',
help=_("A file with expressions that, if found, will be replaced. "
"By default, each expression is treated as literal text, "
"but 'regex:' and 'glob:' prefixes are supported. You can "
"end the line with '==>' and some replacement text to "
"choose a replacement choice other than the default of '{}'."
.format(decode(FilteringOptions.default_replace_text))))
contents.add_argument('--strip-blobs-bigger-than', metavar='SIZE',
dest='max_blob_size', default=0,
help=_("Strip blobs (files) bigger than specified size (e.g. '5M', "
"'2G', etc)"))
contents.add_argument('--strip-blobs-with-ids', metavar='BLOB-ID-FILENAME',
help=_("Read git object ids from each line of the given file, and "
"strip all of them from history"))
refrename = parser.add_argument_group(title=_("Renaming of refs "
"(see also --refname-callback)"))
refrename.add_argument('--tag-rename', metavar='OLD:NEW', type=os.fsencode,
help=_("Rename tags starting with OLD to start with NEW. For "
"example, --tag-rename foo:bar will rename tag foo-1.2.3 "
"to bar-1.2.3; either OLD or NEW can be empty."))
messages = parser.add_argument_group(title=_("Filtering of commit messages "
"(see also --message-callback)"))
messages.add_argument('--replace-message', metavar='EXPRESSIONS_FILE',
help=_("A file with expressions that, if found in commit messages, "
"will be replaced. This file uses the same syntax as "
"--replace-text."))
messages.add_argument('--preserve-commit-hashes', action='store_true',
help=_("By default, since commits are rewritten and thus gain new "
"hashes, references to old commit hashes in commit messages "
"are replaced with new commit hashes (abbreviated to the same "
"length as the old reference). Use this flag to turn off "
"updating commit hashes in commit messages."))
messages.add_argument('--preserve-commit-encoding', action='store_true',
help=_("Do not reencode commit messages into UTF-8. By default, if "
"the commit object specifies an encoding for the commit "
"message, the message is re-encoded into UTF-8."))
people = parser.add_argument_group(title=_("Filtering of names & emails "
"(see also --name-callback "
"and --email-callback)"))
people.add_argument('--mailmap', dest='mailmap', metavar='FILENAME',
type=os.fsencode,
help=_("Use specified mailmap file (see git-shortlog(1) for "
"details on the format) when rewriting author, committer, "
"and tagger names and emails. If the specified file is "
"part of git history, historical versions of the file will "
"be ignored; only the current contents are consulted."))
people.add_argument('--use-mailmap', dest='mailmap',
action='store_const', const=b'.mailmap',
help=_("Same as: '--mailmap .mailmap' "))
parents = parser.add_argument_group(title=_("Parent rewriting"))
parents.add_argument('--replace-refs', default=None,
choices=['delete-no-add', 'delete-and-add',
'update-no-add', 'update-or-add',
'update-and-add'],
help=_("Replace refs (see git-replace(1)) are used to rewrite "
"parents (unless turned off by the usual git mechanism); this "
"flag specifies what do do with those refs afterward. "
"Replace refs can either be deleted or updated to point at new "
"commit hashes. Also, new replace refs can be added for each "
"commit rewrite. With 'update-or-add', new replace refs are "
"only added for commit rewrites that aren't used to update an "
"existing replace ref. default is 'update-and-add' if "
"$GIT_DIR/filter-repo/already_ran does not exist; "
"'update-or-add' otherwise."))
parents.add_argument('--prune-empty', default='auto',
choices=['always', 'auto', 'never'],
help=_("Whether to prune empty commits. 'auto' (the default) means "
"only prune commits which become empty (not commits which were "
"empty in the original repo, unless their parent was pruned). "
"When the parent of a commit is pruned, the first non-pruned "
"ancestor becomes the new parent."))
parents.add_argument('--prune-degenerate', default='auto',
choices=['always', 'auto', 'never'],
help=_("Since merge commits are needed for history topology, they "
"are typically exempt from pruning. However, they can become "
"degenerate with the pruning of other commits (having fewer "
"than two parents, having one commit serve as both parents, or "
"having one parent as the ancestor of the other.) If such "
"merge commits have no file changes, they can be pruned. The "
"default ('auto') is to only prune empty merge commits which "
"become degenerate (not which started as such)."))
parents.add_argument('--no-ff', action='store_true',
help=_("Even if the first parent is or becomes an ancestor of another "
"parent, do not prune it. This modifies how "
"--prune-degenerate behaves, and may be useful in projects who "
"always use merge --no-ff."))
callback = parser.add_argument_group(title=_("Generic callback code snippets"))
callback.add_argument('--filename-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing filenames; see CALLBACKS "
"sections below."))
callback.add_argument('--message-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing messages (both commit "
"messages and tag messages); see CALLBACKS section below."))
callback.add_argument('--name-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing names of people; see "
"CALLBACKS section below."))
callback.add_argument('--email-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing emails addresses; see "
"CALLBACKS section below."))
callback.add_argument('--refname-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing refnames; see CALLBACKS "
"section below."))
callback.add_argument('--blob-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing blob objects; see "
"CALLBACKS section below."))
callback.add_argument('--commit-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing commit objects; see "
"CALLBACKS section below."))
callback.add_argument('--tag-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing tag objects; see CALLBACKS "
"section below."))
callback.add_argument('--reset-callback', metavar="FUNCTION_BODY_OR_FILE",
help=_("Python code body for processing reset objects; see "
"CALLBACKS section below."))
desc = _(
"Specifying alternate source or target locations implies --partial,\n"
"except that the normal default for --replace-refs is used. However,\n"
"unlike normal uses of --partial, this doesn't risk mixing old and new\n"
"history since the old and new histories are in different repositories.")
location = parser.add_argument_group(title=_("Location to filter from/to"),
description=desc)
location.add_argument('--source', type=os.fsencode,
help=_("Git repository to read from"))
location.add_argument('--target', type=os.fsencode,
help=_("Git repository to overwrite with filtered history"))
misc = parser.add_argument_group(title=_("Miscellaneous options"))
misc.add_argument('--help', '-h', action='store_true',
help=_("Show this help message and exit."))
misc.add_argument('--version', action='store_true',
help=_("Display filter-repo's version and exit."))
misc.add_argument('--force', '-f', action='store_true',
help=_("Rewrite repository history even if the current repo does not "
"look like a fresh clone. History rewriting is irreversible "
"(and includes immediate pruning of reflogs and old objects), "
"so be cautious about using this flag."))
misc.add_argument('--partial', action='store_true',
help=_("Do a partial history rewrite, resulting in the mixture of "
"old and new history. This implies a default of "
"update-no-add for --replace-refs, disables rewriting "
"refs/remotes/origin/* to refs/heads/*, disables removing "
"of the 'origin' remote, disables removing unexported refs, "
"disables expiring the reflog, and disables the automatic "
"post-filter gc. Also, this modifies --tag-rename and "
"--refname-callback options such that instead of replacing "
"old refs with new refnames, it will instead create new "
"refs and keep the old ones around. Use with caution."))
# WARNING: --refs presents a problem with become-degenerate pruning:
# * Excluding a commit also excludes its ancestors so when some other
# commit has an excluded ancestor as a parent we have no way of
# knowing what it is an ancestor of without doing a special
# full-graph walk.
misc.add_argument('--refs', nargs='+',
help=_("Limit history rewriting to the specified refs. Implies "
"--partial. In addition to the normal caveats of --partial "
"(mixing old and new history, no automatic remapping of "
"refs/remotes/origin/* to refs/heads/*, etc.), this also may "
"cause problems for pruning of degenerate empty merge "
"commits when negative revisions are specified."))
misc.add_argument('--dry-run', action='store_true',
help=_("Do not change the repository. Run `git fast-export` and "
"filter its output, and save both the original and the "
"filtered version for comparison. This also disables "
"rewriting commit messages due to not knowing new commit "
"IDs and disables filtering of some empty commits due to "
"inability to query the fast-import backend." ))
misc.add_argument('--debug', action='store_true',
help=_("Print additional information about operations being "
"performed and commands being run. When used together "
"with --dry-run, also show extra information about what "
"would be run."))
# WARNING: --state-branch has some problems:
# * It does not work well with manually inserted objects (user creating
# Blob() or Commit() or Tag() objects and calling
# RepoFilter.insert(obj) on them).
# * It does not work well with multiple source or multiple target repos
# * It doesn't work so well with pruning become-empty commits (though
# --refs doesn't work so well with it either)
# These are probably fixable, given some work (e.g. re-importing the
# graph at the beginning to get the AncestryGraph right, doing our own
# export of marks instead of using fast-export --export-marks, etc.), but
# for now just hide the option.
misc.add_argument('--state-branch',
#help=_("Enable incremental filtering by saving the mapping of old "
# "to new objects to the specified branch upon exit, and"
# "loading that mapping from that branch (if it exists) "
# "upon startup."))
help=argparse.SUPPRESS)
misc.add_argument('--stdin', action='store_true',
help=_("Instead of running `git fast-export` and filtering its "
"output, filter the fast-export stream from stdin. The "
"stdin must be in the expected input format (e.g. it needs "
"to include original-oid directives)."))
misc.add_argument('--quiet', action='store_true',
help=_("Pass --quiet to other git commands called"))
return parser
@staticmethod
def sanity_check_args(args):
if args.analyze and args.path_changes:
raise SystemExit(_("Error: --analyze is incompatible with --path* flags; "
"it's a read-only operation."))
if args.analyze and args.stdin:
raise SystemExit(_("Error: --analyze is incompatible with --stdin."))
# If no path_changes are found, initialize with empty list but mark as
# not inclusive so that all files match
if args.path_changes == None:
args.path_changes = []
args.inclusive = False
else:
# Similarly, if we have no filtering paths, then no path should be
# filtered out. Based on how newname() works, the easiest way to
# achieve that is setting args.inclusive to False.
if not any(x[0] == 'filter' for x in args.path_changes):
args.inclusive = False
# Also check for incompatible --use-base-name and --path-rename flags.
if args.use_base_name:
if any(x[0] == 'rename' for x in args.path_changes):
raise SystemExit(_("Error: --use-base-name and --path-rename are "
"incompatible."))
# Also throw some sanity checks on git version here;
# PERF: remove these checks once new enough git versions are common
p = subproc.Popen('git fast-export -h'.split(),
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output = p.stdout.read()
if b'--anonymize-map' not in output: # pragma: no cover
global date_format_permissive
date_format_permissive = False
if b'--mark-tags' not in output: # pragma: no cover
global write_marks
write_marks = False
if args.state_branch:
# We need a version of git-fast-export with --mark-tags
raise SystemExit(_("Error: need git >= 2.24.0"))
if b'--reencode' not in output: # pragma: no cover
if args.preserve_commit_encoding:
# We need a version of git-fast-export with --reencode
raise SystemExit(_("Error: need git >= 2.23.0"))
else:
# Set args.preserve_commit_encoding to None which we'll check for later
# to avoid passing --reencode=yes to fast-export (that option was the
# default prior to git-2.23)
args.preserve_commit_encoding = None
# If we don't have fast-exoprt --reencode, we may also be missing
# diff-tree --combined-all-paths, which is even more important...
p = subproc.Popen('git diff-tree -h'.split(),
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output = p.stdout.read()
if b'--combined-all-paths' not in output:
# We need a version of git-diff-tree with --combined-all-paths
raise SystemExit(_("Error: need git >= 2.22.0"))
# End of sanity checks on git version
if args.max_blob_size:
suffix = args.max_blob_size[-1]
if suffix not in '1234567890':
mult = {'K': 1024, 'M': 1024**2, 'G': 1024**3}
if suffix not in mult:
raise SystemExit(_("Error: could not parse --strip-blobs-bigger-than"
" argument %s")
% args.max_blob_size)
args.max_blob_size = int(args.max_blob_size[0:-1]) * mult[suffix]
else:
args.max_blob_size = int(args.max_blob_size)
@staticmethod
def get_replace_text(filename):
replace_literals = []
replace_regexes = []
with open(filename, 'br') as f:
for line in f:
line = line.rstrip(b'\r\n')
# Determine the replacement
replacement = FilteringOptions.default_replace_text
if b'==>' in line:
line, replacement = line.rsplit(b'==>', 1)
# See if we need to match via regex
regex = None
if line.startswith(b'regex:'):
regex = line[6:]
elif line.startswith(b'glob:'):
regex = glob_to_regex(line[5:])
if regex:
replace_regexes.append((re.compile(regex), replacement))
else:
# Otherwise, find the literal we need to replace
if line.startswith(b'literal:'):
line = line[8:]
if not line:
continue
replace_literals.append((line, replacement))
return {'literals': replace_literals, 'regexes': replace_regexes}
@staticmethod
def get_paths_from_file(filename):
new_path_changes = []
with open(filename, 'br') as f:
for line in f:
line = line.rstrip(b'\r\n')
# Skip blank lines
if not line:
continue
# Skip comment lines
if line.startswith(b'#'):
continue
# Determine the replacement
match_type, repl = 'literal', None
if b'==>' in line:
line, repl = line.rsplit(b'==>', 1)
# See if we need to match via regex
match_type = 'match' # a.k.a. 'literal'
if line.startswith(b'regex:'):
match_type = 'regex'
match = re.compile(line[6:])
elif line.startswith(b'glob:'):
match_type = 'glob'
match = line[5:]
if repl:
raise SystemExit(_("Error: In %s, 'glob:' and '==>' are incompatible (renaming globs makes no sense)" % decode(filename)))
else:
if line.startswith(b'literal:'):
match = line[8:]
else:
match = line
if repl is not None:
if match and repl and match.endswith(b'/') != repl.endswith(b'/'):
raise SystemExit(_("Error: When rename directories, if OLDNAME "
"and NEW_NAME are both non-empty and either "
"ends with a slash then both must."))
# Record the filter or rename
if repl is not None:
new_path_changes.append(['rename', match_type, (match, repl)])
else:
new_path_changes.append(['filter', match_type, match])
if match_type == 'glob' and not match.endswith(b'*'):
extension = b'*' if match.endswith(b'/') else b'/*'
new_path_changes.append(['filter', match_type, match+extension])
return new_path_changes
@staticmethod
def default_options():
return FilteringOptions.parse_args([], error_on_empty = False)
@staticmethod
def parse_args(input_args, error_on_empty = True):
parser = FilteringOptions.create_arg_parser()
if not input_args and error_on_empty:
parser.print_usage()
raise SystemExit(_("No arguments specified."))
args = parser.parse_args(input_args)
if args.help:
parser.print_help()
raise SystemExit()
if args.version:
GitUtils.print_my_version()
raise SystemExit()
FilteringOptions.sanity_check_args(args)
if args.mailmap:
args.mailmap = MailmapInfo(args.mailmap)
if args.replace_text:
args.replace_text = FilteringOptions.get_replace_text(args.replace_text)
if args.replace_message:
args.replace_message = FilteringOptions.get_replace_text(args.replace_message)
if args.strip_blobs_with_ids:
with open(args.strip_blobs_with_ids, 'br') as f:
args.strip_blobs_with_ids = set(f.read().split())
else:
args.strip_blobs_with_ids = set()
if (args.partial or args.refs) and not args.replace_refs:
args.replace_refs = 'update-no-add'
args.repack = not (args.partial or args.refs)
if args.refs or args.source or args.target:
args.partial = True
if not args.refs:
args.refs = ['--all']
return args
class RepoAnalyze(object):
# First, several helper functions for analyze_commit()
@staticmethod
def equiv_class(stats, filename):
return stats['equivalence'].get(filename, (filename,))
@staticmethod
def setup_equivalence_for_rename(stats, oldname, newname):
# if A is renamed to B and B is renamed to C, then the user thinks of
# A, B, and C as all being different names for the same 'file'. We record
# this as an equivalence class:
# stats['equivalence'][name] = (A,B,C)
# for name being each of A, B, and C.
old_tuple = stats['equivalence'].get(oldname, ())
if newname in old_tuple:
return
elif old_tuple:
new_tuple = tuple(list(old_tuple)+[newname])
else:
new_tuple = (oldname, newname)
for f in new_tuple:
stats['equivalence'][f] = new_tuple
@staticmethod
def setup_or_update_rename_history(stats, commit, oldname, newname):
rename_commits = stats['rename_history'].get(oldname, set())
rename_commits.add(commit)
stats['rename_history'][oldname] = rename_commits
@staticmethod
def handle_renames(stats, commit, change_types, filenames):
for index, change_type in enumerate(change_types):
if change_type == ord(b'R'):
oldname, newname = filenames[index], filenames[-1]
RepoAnalyze.setup_equivalence_for_rename(stats, oldname, newname)
RepoAnalyze.setup_or_update_rename_history(stats, commit,
oldname, newname)
@staticmethod
def handle_file(stats, graph, commit, modes, shas, filenames):
mode, sha, filename = modes[-1], shas[-1], filenames[-1]
# Figure out kind of deletions to undo for this file, and update lists
# of all-names-by-sha and all-filenames
delmode = 'tree_deletions'
if mode != b'040000':
delmode = 'file_deletions'
stats['names'][sha].add(filename)
stats['allnames'].add(filename)
# If the file (or equivalence class of files) was recorded as deleted,
# clearly it isn't anymore
equiv = RepoAnalyze.equiv_class(stats, filename)
for f in equiv:
stats[delmode].pop(f, None)
# If we get a modify/add for a path that was renamed, we may need to break
# the equivalence class. However, if the modify/add was on a branch that
# doesn't have the rename in its history, we are still okay.
need_to_break_equivalence = False
if equiv[-1] != filename:
for rename_commit in stats['rename_history'][filename]:
if graph.is_ancestor(rename_commit, commit):
need_to_break_equivalence = True
if need_to_break_equivalence:
for f in equiv:
if f in stats['equivalence']:
del stats['equivalence'][f]
@staticmethod
def analyze_commit(stats, graph, commit, parents, date, file_changes):
graph.add_commit_and_parents(commit, parents)
for change in file_changes:
modes, shas, change_types, filenames = change
if len(parents) == 1 and change_types.startswith(b'R'):
change_types = b'R' # remove the rename score; we don't care
if modes[-1] == b'160000':
continue
elif modes[-1] == b'000000':
# Track when files/directories are deleted
for f in RepoAnalyze.equiv_class(stats, filenames[-1]):
if any(x == b'040000' for x in modes[0:-1]):
stats['tree_deletions'][f] = date
else:
stats['file_deletions'][f] = date
elif change_types.strip(b'AMT') == b'':
RepoAnalyze.handle_file(stats, graph, commit, modes, shas, filenames)
elif modes[-1] == b'040000' and change_types.strip(b'RAM') == b'':
RepoAnalyze.handle_file(stats, graph, commit, modes, shas, filenames)
elif change_types.strip(b'RAMT') == b'':
RepoAnalyze.handle_file(stats, graph, commit, modes, shas, filenames)
RepoAnalyze.handle_renames(stats, commit, change_types, filenames)
else:
raise SystemExit(_("Unhandled change type(s): %(change_type)s "
"(in commit %(commit)s)")
% ({'change_type': change_types, 'commit': commit})
) # pragma: no cover
@staticmethod
def gather_data(args):
unpacked_size, packed_size = GitUtils.get_blob_sizes()
stats = {'names': collections.defaultdict(set),
'allnames' : set(),
'file_deletions': {},
'tree_deletions': {},
'equivalence': {},
'rename_history': collections.defaultdict(set),
'unpacked_size': unpacked_size,
'packed_size': packed_size,
'num_commits': 0}
# Setup the rev-list/diff-tree process
processed_commits_msg = _("Processed %d commits")
commit_parse_progress = ProgressWriter()
num_commits = 0
cmd = ('git rev-list --topo-order --reverse {}'.format(' '.join(args.refs)) +
' | git diff-tree --stdin --always --root --format=%H%n%P%n%cd' +
' --date=short -M -t -c --raw --combined-all-paths')
dtp = subproc.Popen(cmd, shell=True, bufsize=-1, stdout=subprocess.PIPE)
f = dtp.stdout
line = f.readline()
if not line:
raise SystemExit(_("Nothing to analyze; repository is empty."))
cont = bool(line)
graph = AncestryGraph()
while cont:
commit = line.rstrip()
parents = f.readline().split()
date = f.readline().rstrip()
# We expect a blank line next; if we get a non-blank line then
# this commit modified no files and we need to move on to the next.
# If there is no line, we've reached end-of-input.
line = f.readline()
if not line:
cont = False
line = line.rstrip()
# If we haven't reached end of input, and we got a blank line meaning
# a commit that has modified files, then get the file changes associated
# with this commit.
file_changes = []
if cont and not line:
cont = False
for line in f:
if not line.startswith(b':'):
cont = True
break
n = 1+max(1, len(parents))
assert line.startswith(b':'*(n-1))
relevant = line[n-1:-1]
splits = relevant.split(None, n)
modes = splits[0:n]
splits = splits[n].split(None, n)
shas = splits[0:n]
splits = splits[n].split(b'\t')
change_types = splits[0]
filenames = [PathQuoting.dequote(x) for x in splits[1:]]
file_changes.append([modes, shas, change_types, filenames])
# If someone is trying to analyze a subset of the history, make sure
# to avoid dying on commits with parents that we haven't seen before
if args.refs:
graph.record_external_commits([p for p in parents
if not p in graph.value])
# Analyze this commit and update progress
RepoAnalyze.analyze_commit(stats, graph, commit, parents, date,
file_changes)
num_commits += 1
commit_parse_progress.show(processed_commits_msg % num_commits)
# Show the final commits processed message and record the number of commits
commit_parse_progress.finish()
stats['num_commits'] = num_commits
# Close the output, ensure rev-list|diff-tree pipeline completed successfully
dtp.stdout.close()
if dtp.wait():
raise SystemExit(_("Error: rev-list|diff-tree pipeline failed; see above.")) # pragma: no cover
return stats
@staticmethod
def write_report(reportdir, stats):
def datestr(datetimestr):
return datetimestr if datetimestr else _('<present>').encode()
def dirnames(path):
while True:
path = os.path.dirname(path)
yield path
if path == b'':
break
# Compute aggregate size information for paths, extensions, and dirs
total_size = {'packed': 0, 'unpacked': 0}
path_size = {'packed': collections.defaultdict(int),
'unpacked': collections.defaultdict(int)}
ext_size = {'packed': collections.defaultdict(int),
'unpacked': collections.defaultdict(int)}
dir_size = {'packed': collections.defaultdict(int),
'unpacked': collections.defaultdict(int)}
for sha in stats['names']:
size = {'packed': stats['packed_size'][sha],
'unpacked': stats['unpacked_size'][sha]}
for which in ('packed', 'unpacked'):
for name in stats['names'][sha]:
total_size[which] += size[which]
path_size[which][name] += size[which]
basename, ext = os.path.splitext(name)
ext_size[which][ext] += size[which]
for dirname in dirnames(name):
dir_size[which][dirname] += size[which]
# Determine if and when extensions and directories were deleted
ext_deleted_data = {}
for name in stats['allnames']:
when = stats['file_deletions'].get(name, None)
# Update the extension
basename, ext = os.path.splitext(name)
if when is None:
ext_deleted_data[ext] = None
elif ext in ext_deleted_data:
if ext_deleted_data[ext] is not None:
ext_deleted_data[ext] = max(ext_deleted_data[ext], when)
else:
ext_deleted_data[ext] = when
dir_deleted_data = {}
for name in dir_size['packed']:
dir_deleted_data[name] = stats['tree_deletions'].get(name, None)
with open(os.path.join(reportdir, b"README"), 'bw') as f:
# Give a basic overview of this file
f.write(b"== %s ==\n" % _("Overall Statistics").encode())
f.write((" %s: %d\n" % (_("Number of commits"),
stats['num_commits'])).encode())
f.write((" %s: %d\n" % (_("Number of filenames"),
len(path_size['packed']))).encode())
f.write((" %s: %d\n" % (_("Number of directories"),
len(dir_size['packed']))).encode())
f.write((" %s: %d\n" % (_("Number of file extensions"),
len(ext_size['packed']))).encode())
f.write(b"\n")
f.write((" %s: %d\n" % (_("Total unpacked size (bytes)"),
total_size['unpacked'])).encode())
f.write((" %s: %d\n" % (_("Total packed size (bytes)"),
total_size['packed'])).encode())
f.write(b"\n")
# Mention issues with the report
f.write(("== %s ==\n" % _("Caveats")).encode())
f.write(("=== %s ===\n" % _("Sizes")).encode())
f.write(textwrap.dedent(_("""
Packed size represents what size your repository would be if no
trees, commits, tags, or other metadata were included (though it may
fail to represent de-duplication; see below). It also represents the
current packing, which may be suboptimal if you haven't gc'ed for a
while.
Unpacked size represents what size your repository would be if no
trees, commits, tags, or other metadata were included AND if no
files were packed; i.e., without delta-ing or compression.
Both unpacked and packed sizes can be slightly misleading. Deleting
a blob from history not save as much space as the unpacked size,
because it is obviously normally stored in packed form. Also,
deleting a blob from history may not save as much space as its packed
size either, because another blob could be stored as a delta against
that blob, so when you remove one blob another blob's packed size may
grow.
Also, the sum of the packed sizes can add up to more than the
repository size; if the same contents appeared in the repository in
multiple places, git will automatically de-dupe and store only one
copy, while the way sizes are added in this analysis adds the size
for each file path that has those contents. Further, if a file is
ever reverted to a previous version's contents, the previous
version's size will be counted multiple times in this analysis, even
though git will only store it once.
""")[1:]).encode())
f.write(b"\n")
f.write(("=== %s ===\n" % _("Deletions")).encode())
f.write(textwrap.dedent(_("""
Whether a file is deleted is not a binary quality, since it can be
deleted on some branches but still exist in others. Also, it might
exist in an old tag, but have been deleted in versions newer than
that. More thorough tracking could be done, including looking at
merge commits where one side of history deleted and the other modified,
in order to give a more holistic picture of deletions. However, that
algorithm would not only be more complex to implement, it'd also be
quite difficult to present and interpret by users. Since --analyze
is just about getting a high-level rough picture of history, it instead
implements the simplistic rule that is good enough for 98% of cases:
A file is marked as deleted if the last commit in the fast-export
stream that mentions the file lists it as deleted.
This makes it dependent on topological ordering, but generally gives
the "right" answer.
""")[1:]).encode())
f.write(b"\n")
f.write(("=== %s ===\n" % _("Renames")).encode())
f.write(textwrap.dedent(_("""
Renames share the same non-binary nature that deletions do, plus
additional challenges:
* If the renamed file is renamed again, instead of just two names for
a path you can have three or more.
* Rename pairs of the form (oldname, newname) that we consider to be
different names of the "same file" might only be valid over certain
commit ranges. For example, if a new commit reintroduces a file
named oldname, then new versions of oldname aren't the "same file"
anymore. We could try to portray this to the user, but it's easier
for the user to just break the pairing and only report unbroken
rename pairings to the user.
* The ability for users to rename files differently in different
branches means that our chains of renames will not necessarily be
linear but may branch out.
""")[1:]).encode())
f.write(b"\n")
# Equivalence classes for names, so if folks only want to keep a
# certain set of paths, they know the old names they want to include
# too.
with open(os.path.join(reportdir, b"renames.txt"), 'bw') as f:
seen = set()
for pathname,equiv_group in sorted(stats['equivalence'].items(),
key=lambda x:(x[1], x[0])):
if equiv_group in seen:
continue
seen.add(equiv_group)
f.write(("{} ->\n ".format(decode(equiv_group[0])) +
"\n ".join(decode(x) for x in equiv_group[1:]) +
"\n").encode())
# List directories in reverse sorted order of unpacked size
with open(os.path.join(reportdir, b"directories-deleted-sizes.txt"), 'bw') as f:
msg = "=== %s ===\n" % _("Deleted directories by reverse size")
f.write(msg.encode())
msg = _("Format: unpacked size, packed size, date deleted, directory name\n")
f.write(msg.encode())
for dirname, size in sorted(dir_size['packed'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
if (dir_deleted_data[dirname]):
f.write(b" %10d %10d %-10s %s\n" % (dir_size['unpacked'][dirname],
size,
datestr(dir_deleted_data[dirname]),
dirname or _('<toplevel>').encode()))
with open(os.path.join(reportdir, b"directories-all-sizes.txt"), 'bw') as f:
f.write(("=== %s ===\n" % _("All directories by reverse size")).encode())
msg = _("Format: unpacked size, packed size, date deleted, directory name\n")
f.write(msg.encode())
for dirname, size in sorted(dir_size['packed'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
f.write(b" %10d %10d %-10s %s\n" % (dir_size['unpacked'][dirname],
size,
datestr(dir_deleted_data[dirname]),
dirname or _("<toplevel>").encode()))
# List extensions in reverse sorted order of unpacked size
with open(os.path.join(reportdir, b"extensions-deleted-sizes.txt"), 'bw') as f:
msg = "=== %s ===\n" % _("Deleted extensions by reverse size")
f.write(msg.encode())
msg = _("Format: unpacked size, packed size, date deleted, extension name\n")
f.write(msg.encode())
for extname, size in sorted(ext_size['packed'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
if (ext_deleted_data[extname]):
f.write(b" %10d %10d %-10s %s\n" % (ext_size['unpacked'][extname],
size,
datestr(ext_deleted_data[extname]),
extname or _('<no extension>').encode()))
with open(os.path.join(reportdir, b"extensions-all-sizes.txt"), 'bw') as f:
f.write(("=== %s ===\n" % _("All extensions by reverse size")).encode())
msg = _("Format: unpacked size, packed size, date deleted, extension name\n")
f.write(msg.encode())
for extname, size in sorted(ext_size['packed'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
f.write(b" %10d %10d %-10s %s\n" % (ext_size['unpacked'][extname],
size,
datestr(ext_deleted_data[extname]),
extname or _('<no extension>').encode()))
# List files in reverse sorted order of unpacked size
with open(os.path.join(reportdir, b"path-deleted-sizes.txt"), 'bw') as f:
msg = "=== %s ===\n" % _("Deleted paths by reverse accumulated size")
f.write(msg.encode())
msg = _("Format: unpacked size, packed size, date deleted, path name(s)\n")
f.write(msg.encode())
for pathname, size in sorted(path_size['packed'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
when = stats['file_deletions'].get(pathname, None)
if when:
f.write(b" %10d %10d %-10s %s\n" % (path_size['unpacked'][pathname],
size,
datestr(when),
pathname))
with open(os.path.join(reportdir, b"path-all-sizes.txt"), 'bw') as f:
msg = "=== %s ===\n" % _("All paths by reverse accumulated size")
f.write(msg.encode())
msg = _("Format: unpacked size, packed size, date deleted, path name\n")
f.write(msg.encode())
for pathname, size in sorted(path_size['packed'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
when = stats['file_deletions'].get(pathname, None)
f.write(b" %10d %10d %-10s %s\n" % (path_size['unpacked'][pathname],
size,
datestr(when),
pathname))
# List of filenames and sizes in descending order
with open(os.path.join(reportdir, b"blob-shas-and-paths.txt"), 'bw') as f:
f.write(("=== %s ===\n" % _("Files by sha and associated pathnames in reverse size")).encode())
f.write(_("Format: sha, unpacked size, packed size, filename(s) object stored as\n").encode())
for sha, size in sorted(stats['packed_size'].items(),
key=lambda x:(x[1],x[0]), reverse=True):
if sha not in stats['names']:
# Some objects in the repository might not be referenced, or not
# referenced by the branches/tags the user cares about; skip them.
continue
names_with_sha = stats['names'][sha]
if len(names_with_sha) == 1:
names_with_sha = names_with_sha.pop()
else:
names_with_sha = b'[' + b', '.join(sorted(names_with_sha)) + b']'
f.write(b" %s %10d %10d %s\n" % (sha,
stats['unpacked_size'][sha],
size,
names_with_sha))
@staticmethod
def run(args):
if args.report_dir:
reportdir = args.report_dir
else:
git_dir = GitUtils.determine_git_dir(b'.')
# Create the report directory as necessary
results_tmp_dir = os.path.join(git_dir, b'filter-repo')
if not os.path.isdir(results_tmp_dir):
os.mkdir(results_tmp_dir)
reportdir = os.path.join(results_tmp_dir, b"analysis")
if os.path.isdir(reportdir):
if args.force:
sys.stdout.write(_("Warning: Removing recursively: \"%s\"") % decode(reportdir))
shutil.rmtree(reportdir)
else:
sys.stdout.write(_("Error: dir already exists (use --force to delete): \"%s\"\n") % decode(reportdir))
sys.exit(1)
os.mkdir(reportdir)
# Gather the data we need
stats = RepoAnalyze.gather_data(args)
# Write the reports
sys.stdout.write(_("Writing reports to %s...") % decode(reportdir))
sys.stdout.flush()
RepoAnalyze.write_report(reportdir, stats)
sys.stdout.write(_("done.\n"))
class InputFileBackup:
def __init__(self, input_file, output_file):
self.input_file = input_file
self.output_file = output_file
def close(self):
self.input_file.close()
self.output_file.close()
def read(self, size):
output = self.input_file.read(size)
self.output_file.write(output)
return output
def readline(self):
line = self.input_file.readline()
self.output_file.write(line)
return line
class DualFileWriter:
def __init__(self, file1, file2):
self.file1 = file1
self.file2 = file2
def write(self, *args):
self.file1.write(*args)
self.file2.write(*args)
def flush(self):
self.file1.flush()
self.file2.flush()
def close(self):
self.file1.close()
self.file2.close()
class RepoFilter(object):
def __init__(self,
args,
filename_callback = None,
message_callback = None,
name_callback = None,
email_callback = None,
refname_callback = None,
blob_callback = None,
commit_callback = None,
tag_callback = None,
reset_callback = None,
done_callback = None):
self._args = args
# Repo we are exporting
self._repo_working_dir = None
# Store callbacks for acting on objects printed by FastExport
self._blob_callback = blob_callback
self._commit_callback = commit_callback
self._tag_callback = tag_callback
self._reset_callback = reset_callback
self._done_callback = done_callback
# Store callbacks for acting on slices of FastExport objects
self._filename_callback = filename_callback # filenames from commits
self._message_callback = message_callback # commit OR tag message
self._name_callback = name_callback # author, committer, tagger
self._email_callback = email_callback # author, committer, tagger
self._refname_callback = refname_callback # from commit/tag/reset
self._handle_arg_callbacks()
# Defaults for input
self._input = None
self._fep = None # Fast Export Process
self._fe_orig = None # Path to where original fast-export output stored
self._fe_filt = None # Path to where filtered fast-export output stored
self._parser = None # FastExportParser object we are working with
# Defaults for output
self._output = None
self._fip = None # Fast Import Process
self._import_pipes = None
self._managed_output = True
# A tuple of (depth, list-of-ancestors). Commits and ancestors are
# identified by their id (their 'mark' in fast-export or fast-import
# speak). The depth of a commit is one more than the max depth of any
# of its ancestors.
self._graph = AncestryGraph()
# Another one, for ancestry of commits in the original repo
self._orig_graph = AncestryGraph()
# Names of files that were tweaked in any commit; such paths could lead
# to subsequent commits being empty
self._files_tweaked = set()
# A set of commit hash pairs (oldhash, newhash) which used to be merge
# commits but due to filtering were turned into non-merge commits.
# The commits probably have suboptimal commit messages (e.g. "Merge branch
# next into master").
self._commits_no_longer_merges = []
# A dict of original_ids to new_ids; filtering commits means getting
# new commit hash (sha1sums), and we record the mapping both for
# diagnostic purposes and so we can rewrite commit messages. Note that
# the new_id can be None rather than a commit hash if the original
# commit became empty and was pruned or was otherwise dropped.
self._commit_renames = {}
# A set of original_ids for which we have not yet gotten the
# new_ids; we use OrderedDict because we need to know the order of
# insertion, but the values are always ignored (and set to None).
# If there was an OrderedSet class, I'd use it instead.
self._pending_renames = collections.OrderedDict()
# A dict of commit_hash[0:7] -> set(commit_hashes with that prefix).
#
# It's common for commit messages to refer to commits by abbreviated
# commit hashes, as short as 7 characters. To facilitate translating
# such short hashes, we have a mapping of prefixes to full old hashes.
self._commit_short_old_hashes = collections.defaultdict(set)
# A set of commit hash references appearing in commit messages which
# mapped to a valid commit that was removed entirely in the filtering
# process. The commit message will continue to reference the
# now-missing commit hash, since there was nothing to map it to.
self._commits_referenced_but_removed = set()
# Progress handling (number of commits parsed, etc.)
self._progress_writer = ProgressWriter()
self._num_commits = 0
# Size of blobs in the repo
self._unpacked_size = {}
# Other vars
self._sanity_checks_handled = False
self._finalize_handled = False
self._orig_refs = None
self._newnames = {}
# Cache a few message translations for performance reasons
self._parsed_message = _("Parsed %d commits")
# Compile some regexes and cache those
self._hash_re = re.compile(br'(\b[0-9a-f]{7,40}\b)')
def _handle_arg_callbacks(self):
def make_callback(argname, str):
exec('def callback({}, _do_not_use_this_var = None):\n'.format(argname)+
' '+'\n '.join(str.splitlines()), globals())
return callback #namespace['callback']
def handle(type):
callback_field = '_{}_callback'.format(type)
code_string = getattr(self._args, type+'_callback')
if code_string:
if os.path.exists(code_string):
with open(code_string, 'r', encoding='utf-8') as f:
code_string = f.read()
if getattr(self, callback_field):
raise SystemExit(_("Error: Cannot pass a %s_callback to RepoFilter "
"AND pass --%s-callback"
% (type, type)))
if 'return ' not in code_string and \
type not in ('blob', 'commit', 'tag', 'reset'):
raise SystemExit(_("Error: --%s-callback should have a return statement")
% type)
setattr(self, callback_field, make_callback(type, code_string))
handle('filename')
handle('message')
handle('name')
handle('email')
handle('refname')
handle('blob')
handle('commit')
handle('tag')
handle('reset')
def _run_sanity_checks(self):
self._sanity_checks_handled = True
if not self._managed_output:
if not self._args.replace_refs:
# If not _managed_output we don't want to make extra changes to the
# repo, so set default to no-op 'update-no-add'
self._args.replace_refs = 'update-no-add'
return
if self._args.debug:
print("[DEBUG] Passed arguments:\n{}".format(self._args))
# Determine basic repository information
target_working_dir = self._args.target or b'.'
self._orig_refs = GitUtils.get_refs(target_working_dir)
is_bare = GitUtils.is_repository_bare(target_working_dir)
# Determine if this is second or later run of filter-repo
tmp_dir = self.results_tmp_dir(create_if_missing=False)
already_ran = os.path.isfile(os.path.join(tmp_dir, b'already_ran'))
# Default for --replace-refs
if not self._args.replace_refs:
self._args.replace_refs = ('update-or-add' if already_ran
else 'update-and-add')
# Do sanity checks from the correct directory
if not self._args.force and not already_ran:
cwd = os.getcwd()
os.chdir(target_working_dir)
RepoFilter.sanity_check(self._orig_refs, is_bare)
os.chdir(cwd)
@staticmethod
def sanity_check(refs, is_bare):
def abort(reason):
try:
cmd = 'git config remote.origin.url'
output = subproc.check_output(cmd.split()).strip()
except subprocess.CalledProcessError as e:
output = None
msg = ""
if output and os.path.isdir(output):
msg = _("Note: when cloning local repositories, you need to pass\n"
" --no-local to git clone to avoid this issue.\n")
raise SystemExit(
_("Aborting: Refusing to destructively overwrite repo history since\n"
"this does not look like a fresh clone.\n"
" (%s)\n%s"
"Please operate on a fresh clone instead. If you want to proceed\n"
"anyway, use --force.") % (reason, msg))
# Make sure repo is fully packed, just like a fresh clone would be.
# Note that transfer.unpackLimit defaults to 100, meaning that a
# repository with no packs and less than 100 objects should be considered
# fully packed.
output = subproc.check_output('git count-objects -v'.split())
stats = dict(x.split(b': ') for x in output.splitlines())
num_packs = int(stats[b'packs'])
num_loose_objects = int(stats[b'count'])
if num_packs > 1 or \
(num_packs == 1 and num_loose_objects > 0) or \
num_loose_objects >= 100:
abort(_("expected freshly packed repo"))
# Make sure there is precisely one remote, named "origin"...or that this
# is a new bare repo with no packs and no remotes
output = subproc.check_output('git remote'.split()).strip()
if not (output == b"origin" or (num_packs == 0 and not output)):
abort(_("expected one remote, origin"))
# Avoid letting people running with weird setups and overwriting GIT_DIR
# elsewhere
git_dir = GitUtils.determine_git_dir(b'.')
if is_bare and git_dir != b'.':
abort(_("GIT_DIR must be ."))
elif not is_bare and git_dir != b'.git':
abort(_("GIT_DIR must be .git"))
# Make sure that all reflogs have precisely one entry
reflog_dir=os.path.join(git_dir, b'logs')
for root, dirs, files in os.walk(reflog_dir):
for filename in files:
pathname = os.path.join(root, filename)
with open(pathname, 'br') as f:
if len(f.read().splitlines()) > 1:
shortpath = pathname[len(reflog_dir)+1:]
abort(_("expected at most one entry in the reflog for %s") %
decode(shortpath))
# Make sure there are no stashed changes
if b'refs/stash' in refs:
abort(_("has stashed changes"))
# Do extra checks in non-bare repos
if not is_bare:
# Avoid uncommitted, unstaged, or untracked changes
if subproc.call('git diff --staged --quiet'.split()):
abort(_("you have uncommitted changes"))
if subproc.call('git diff --quiet'.split()):
abort(_("you have unstaged changes"))
if len(subproc.check_output('git ls-files -o'.split())) > 0:
abort(_("you have untracked changes"))
# Avoid unpushed changes
for refname, rev in refs.items():
if not refname.startswith(b'refs/heads/'):
continue
origin_ref = refname.replace(b'refs/heads/', b'refs/remotes/origin/')
if origin_ref not in refs:
abort(_('%s exists, but %s not found') % (decode(refname),
decode(origin_ref)))
if rev != refs[origin_ref]:
abort(_('%s does not match %s') % (decode(refname),
decode(origin_ref)))
# Make sure there is only one worktree
output = subproc.check_output('git worktree list'.split())
if len(output.splitlines()) > 1:
abort(_('you have multiple worktrees'))
@staticmethod
def cleanup(repo, repack, reset, run_quietly=False, show_debuginfo=False):
''' cleanup repo; if repack then expire reflogs and do a gc --prune=now.
if reset then do a reset --hard. Optionally also curb output if
run_quietly is True, or go the opposite direction and show extra
output if show_debuginfo is True. '''
assert not (run_quietly and show_debuginfo)
if (repack and not run_quietly and not show_debuginfo):
print(_("Repacking your repo and cleaning out old unneeded objects"))
quiet_flags = '--quiet' if run_quietly else ''
cleanup_cmds = []
if repack:
cleanup_cmds = ['git reflog expire --expire=now --all'.split(),
'git gc {} --prune=now'.format(quiet_flags).split()]
if reset:
cleanup_cmds.insert(0, 'git reset {} --hard'.format(quiet_flags).split())
location_info = ' (in {})'.format(decode(repo)) if repo != b'.' else ''
for cmd in cleanup_cmds:
if show_debuginfo:
print("[DEBUG] Running{}: {}".format(location_info, ' '.join(cmd)))
subproc.call(cmd, cwd=repo)
def _get_rename(self, old_hash):
# If we already know the rename, just return it
new_hash = self._commit_renames.get(old_hash, None)
if new_hash:
return new_hash
# If it's not in the remaining pending renames, we don't know it
if old_hash is not None and old_hash not in self._pending_renames:
return None
# Read through the pending renames until we find it or we've read them all,
# and return whatever we might find
self._flush_renames(old_hash)
return self._commit_renames.get(old_hash, None)
def _flush_renames(self, old_hash=None, limit=0):
# Parse through self._pending_renames until we have read enough. We have
# read enough if:
# self._pending_renames is empty
# old_hash != None and we found a rename for old_hash
# limit > 0 and len(self._pending_renames) started less than 2*limit
# limit > 0 and len(self._pending_renames) < limit
if limit and len(self._pending_renames) < 2 * limit:
return
fi_input, fi_output = self._import_pipes
while self._pending_renames:
orig_id, ignore = self._pending_renames.popitem(last=False)
new_id = fi_output.readline().rstrip()
self._commit_renames[orig_id] = new_id
if old_hash == orig_id:
return
if limit and len(self._pending_renames) < limit:
return
def _translate_commit_hash(self, matchobj_or_oldhash):
old_hash = matchobj_or_oldhash
if not isinstance(matchobj_or_oldhash, bytes):
old_hash = matchobj_or_oldhash.group(1)
orig_len = len(old_hash)
new_hash = self._get_rename(old_hash)
if new_hash is None:
if old_hash[0:7] not in self._commit_short_old_hashes:
self._commits_referenced_but_removed.add(old_hash)
return old_hash
possibilities = self._commit_short_old_hashes[old_hash[0:7]]
matches = [x for x in possibilities
if x[0:orig_len] == old_hash]
if len(matches) != 1:
self._commits_referenced_but_removed.add(old_hash)
return old_hash
old_hash = matches[0]
new_hash = self._get_rename(old_hash)
assert new_hash is not None
return new_hash[0:orig_len]
def _trim_extra_parents(self, orig_parents, parents):
'''Due to pruning of empty commits, some parents could be non-existent
(None) or otherwise redundant. Remove the non-existent parents, and
remove redundant parents so long as that doesn't transform a merge
commit into a non-merge commit.
Returns a tuple:
(parents, new_first_parent_if_would_become_non_merge)'''
always_prune = (self._args.prune_degenerate == 'always')
# Pruning of empty commits means multiple things:
# * An original parent of this commit may have been pruned causing the
# need to rewrite the reported parent to the nearest ancestor. We
# want to know when we're dealing with such a parent.
# * Further, there may be no "nearest ancestor" if the entire history
# of that parent was also pruned. (Detectable by the parent being
# 'None')
# Remove all parents rewritten to None, and keep track of which parents
# were rewritten to an ancestor.
tmp = zip(parents,
orig_parents,
[(x in _SKIPPED_COMMITS or always_prune) for x in orig_parents])
tmp2 = [x for x in tmp if x[0] is not None]
if not tmp2:
# All ancestors have been pruned; we have no parents.
return [], None
parents, orig_parents, is_rewritten = [list(x) for x in zip(*tmp2)]
# We can't have redundant parents if we don't have at least 2 parents
if len(parents) < 2:
return parents, None
# Don't remove redundant parents if user doesn't want us to
if self._args.prune_degenerate == 'never':
return parents, None
# Remove duplicate parents (if both sides of history have lots of commits
# which become empty due to pruning, the most recent ancestor on both
# sides may be the same commit), except only remove parents that have
# been rewritten due to previous empty pruning.
seen = set()
seen_add = seen.add
# Deleting duplicate rewritten parents means keeping parents if either
# they have not been seen or they are ones that have not been rewritten.
parents_copy = parents
uniq = [[p, orig_parents[i], is_rewritten[i]] for i, p in enumerate(parents)
if not (p in seen or seen_add(p)) or not is_rewritten[i]]
parents, orig_parents, is_rewritten = [list(x) for x in zip(*uniq)]
if len(parents) < 2:
return parents_copy, parents[0]
# Flatten unnecessary merges. (If one side of history is entirely
# empty commits that were pruned, we may end up attempting to
# merge a commit with its ancestor. Remove parents that are an
# ancestor of another parent.)
num_parents = len(parents)
to_remove = []
for cur in range(num_parents):
if not is_rewritten[cur]:
continue
for other in range(num_parents):
if cur == other:
continue
if not self._graph.is_ancestor(parents[cur], parents[other]):
continue
# parents[cur] is an ancestor of parents[other], so parents[cur]
# seems redundant. However, if it was intentionally redundant
# (e.g. a no-ff merge) in the original, then we want to keep it.
if not always_prune and \
self._orig_graph.is_ancestor(orig_parents[cur],
orig_parents[other]):
continue
# Some folks want their history to have all first parents be merge
# commits (except for any root commits), and always do a merge --no-ff.
# For such folks, don't remove the first parent even if it's an
# ancestor of other commits.
if self._args.no_ff and cur == 0:
continue
# Okay so the cur-th parent is an ancestor of the other-th parent,
# and it wasn't that way in the original repository; mark the
# cur-th parent as removable.
to_remove.append(cur)
break # cur removed, so skip rest of others -- i.e. check cur+=1
for x in reversed(to_remove):
parents.pop(x)
if len(parents) < 2:
return parents_copy, parents[0]
return parents, None
def _prunable(self, commit, new_1st_parent, had_file_changes, orig_parents):
parents = commit.parents
if self._args.prune_empty == 'never':
return False
always_prune = (self._args.prune_empty == 'always')
# For merge commits, unless there are prunable (redundant) parents, we
# do not want to prune
if len(parents) >= 2 and not new_1st_parent:
return False
if len(parents) < 2:
# Special logic for commits that started empty...
if not had_file_changes and not always_prune:
had_parents_pruned = (len(parents) < len(orig_parents) or
(len(orig_parents) == 1 and
orig_parents[0] in _SKIPPED_COMMITS))
# If the commit remains empty and had parents which were pruned,
# then prune this commit; otherwise, retain it
return (not commit.file_changes and had_parents_pruned)
# We can only get here if the commit didn't start empty, so if it's
# empty now, it obviously became empty
if not commit.file_changes:
return True
# If there are no parents of this commit and we didn't match the case
# above, then this commit cannot be pruned. Since we have no parent(s)
# to compare to, abort now to prevent future checks from failing.
if not parents:
return False
# Similarly, we cannot handle the hard cases if we don't have a pipe
# to communicate with fast-import
if not self._import_pipes:
return False
# If there have not been renames/remappings of IDs (due to insertion of
# new blobs), then we can sometimes know things aren't prunable with a
# simple check
if not _IDS.has_renames():
# non-merge commits can only be empty if blob/file-change editing caused
# all file changes in the commit to have the same file contents as
# the parent.
changed_files = set(change.filename for change in commit.file_changes)
if len(orig_parents) < 2 and changed_files - self._files_tweaked:
return False
# Finally, the hard case: due to either blob rewriting, or due to pruning
# of empty commits wiping out the first parent history back to the merge
# base, the list of file_changes we have may not actually differ from our
# (new) first parent's version of the files, i.e. this would actually be
# an empty commit. Check by comparing the contents of this commit to its
# (remaining) parent.
#
# NOTE on why this works, for the case of original first parent history
# having been pruned away due to being empty:
# The first parent history having been pruned away due to being
# empty implies the original first parent would have a tree (after
# filtering) that matched the merge base's tree. Since
# file_changes has the changes needed to go from what would have
# been the first parent to our new commit, and what would have been
# our first parent has a tree that matches the merge base, then if
# the new first parent has a tree matching the versions of files in
# file_changes, then this new commit is empty and thus prunable.
fi_input, fi_output = self._import_pipes
self._flush_renames() # Avoid fi_output having other stuff present
# Optimization note: we could have two loops over file_changes, the
# first doing all the self._output.write() calls, and the second doing
# the rest. But I'm worried about fast-import blocking on fi_output
# buffers filling up so I instead read from it as I go.
for change in commit.file_changes:
parent = new_1st_parent or commit.parents[0] # exists due to above checks
quoted_filename = PathQuoting.enquote(change.filename)
if isinstance(parent, int):
self._output.write(b"ls :%d %s\n" % (parent, quoted_filename))
else:
self._output.write(b"ls %s %s\n" % (parent, quoted_filename))
self._output.flush()
parent_version = fi_output.readline().split()
if change.type == b'D':
if parent_version != [b'missing', quoted_filename]:
return False
else:
blob_sha = change.blob_id
if isinstance(change.blob_id, int):
self._output.write(b"get-mark :%d\n" % change.blob_id)
self._output.flush()
blob_sha = fi_output.readline().rstrip()
if parent_version != [change.mode, b'blob', blob_sha, quoted_filename]:
return False
return True
def _record_remapping(self, commit, orig_parents):
new_id = None
# Record the mapping of old commit hash to new one
if commit.original_id and self._import_pipes:
fi_input, fi_output = self._import_pipes
self._output.write(b"get-mark :%d\n" % commit.id)
self._output.flush()
orig_id = commit.original_id
self._commit_short_old_hashes[orig_id[0:7]].add(orig_id)
# Note that we have queued up an id for later reading; flush a
# few of the older ones if we have too many queued up
self._pending_renames[orig_id] = None
self._flush_renames(None, limit=40)
# Also, record if this was a merge commit that turned into a non-merge
# commit.
if len(orig_parents) >= 2 and len(commit.parents) < 2:
self._commits_no_longer_merges.append((commit.original_id, new_id))
def callback_metadata(self, extra_items = dict()):
return {'commit_rename_func': self._translate_commit_hash,
'ancestry_graph': self._graph,
'original_ancestry_graph': self._orig_graph,
**extra_items}
def _tweak_blob(self, blob):
if self._args.max_blob_size and len(blob.data) > self._args.max_blob_size:
blob.skip()
if blob.original_id in self._args.strip_blobs_with_ids:
blob.skip()
if ( self._args.replace_text
# not (if blob contains zero byte in the first 8Kb, that is, if blob is binary data)
and not b"\0" in blob.data[0:8192]
):
for literal, replacement in self._args.replace_text['literals']:
blob.data = blob.data.replace(literal, replacement)
for regex, replacement in self._args.replace_text['regexes']:
blob.data = regex.sub(replacement, blob.data)
if self._blob_callback:
self._blob_callback(blob, self.callback_metadata())
def _filter_files(self, commit):
def filename_matches(path_expression, pathname):
''' Returns whether path_expression matches pathname or a leading
directory thereof, allowing path_expression to not have a trailing
slash even if it is meant to match a leading directory. '''
if path_expression == b'':
return True
n = len(path_expression)
if (pathname.startswith(path_expression) and
(path_expression[n-1:n] == b'/' or
len(pathname) == n or
pathname[n:n+1] == b'/')):
return True
return False
def newname(path_changes, pathname, use_base_name, filtering_is_inclusive):
''' Applies filtering and rename changes from path_changes to pathname,
returning any of None (file isn't wanted), original filename (file
is wanted with original name), or new filename. '''
wanted = False
full_pathname = pathname
if use_base_name:
pathname = os.path.basename(pathname)
for (mod_type, match_type, path_exp) in path_changes:
if mod_type == 'filter' and not wanted:
assert match_type in ('match', 'glob', 'regex')
if match_type == 'match' and filename_matches(path_exp, pathname):
wanted = True
if match_type == 'glob' and fnmatch.fnmatch(pathname, path_exp):
wanted = True
if match_type == 'regex' and path_exp.search(pathname):
wanted = True
elif mod_type == 'rename':
match, repl = path_exp
assert match_type in ('match','regex') # glob was translated to regex
if match_type == 'match' and filename_matches(match, full_pathname):
full_pathname = full_pathname.replace(match, repl, 1)
if match_type == 'regex':
full_pathname = match.sub(repl, full_pathname)
return full_pathname if (wanted == filtering_is_inclusive) else None
args = self._args
new_file_changes = {} # Assumes no renames or copies, otherwise collisions
for change in commit.file_changes:
# NEEDSWORK: _If_ we ever want to pass `--full-tree` to fast-export and
# parse that output, we'll need to modify this block; `--full-tree`
# issues a deleteall directive which has no filename, and thus this
# block would normally strip it. Of course, FileChange() and
# _parse_optional_filechange() would need updates too.
if change.type == b'DELETEALL':
new_file_changes[b''] = change
continue
if change.filename in self._newnames:
change.filename = self._newnames[change.filename]
else:
original_filename = change.filename
change.filename = newname(args.path_changes, change.filename,
args.use_base_name, args.inclusive)
if self._filename_callback:
change.filename = self._filename_callback(change.filename)
self._newnames[original_filename] = change.filename
if not change.filename:
continue # Filtering criteria excluded this file; move on to next one
if change.filename in new_file_changes:
# Getting here means that path renaming is in effect, and caused one
# path to collide with another. That's usually bad, but can be okay
# under two circumstances:
# 1) Sometimes people have a file named OLDFILE in old revisions of
# history, and they rename to NEWFILE, and would like to rewrite
# history so that all revisions refer to it as NEWFILE. As such,
# we can allow a collision when (at least) one of the two paths
# is a deletion. Note that if OLDFILE and NEWFILE are unrelated
# this also allows the rewrite to continue, which makes sense
# since OLDFILE is no longer in the way.
# 2) If OLDFILE and NEWFILE are exactly equal, then writing them
# both to the same location poses no problem; we only need one
# file. (This could come up if someone copied a file in some
# commit, then later either deleted the file or kept it exactly
# in sync with the original with any changes, and then decides
# they want to rewrite history to only have one of the two files)
colliding_change = new_file_changes[change.filename]
if change.type == b'D':
# We can just throw this one away and keep the other
continue
elif change.type == b'M' and (
change.mode == colliding_change.mode and
change.blob_id == colliding_change.blob_id):
# The two are identical, so we can throw this one away and keep other
continue
elif new_file_changes[change.filename].type != b'D':
raise SystemExit(_("File renaming caused colliding pathnames!\n") +
_(" Commit: {}\n").format(commit.original_id) +
_(" Filename: {}").format(change.filename))
# Strip files that are too large
if self._args.max_blob_size and \
self._unpacked_size.get(change.blob_id, 0) > self._args.max_blob_size:
continue
if self._args.strip_blobs_with_ids and \
change.blob_id in self._args.strip_blobs_with_ids:
continue
# Otherwise, record the change
new_file_changes[change.filename] = change
commit.file_changes = [v for k,v in sorted(new_file_changes.items())]
def _tweak_commit(self, commit, aux_info):
# Change the commit message according to callback
if not self._args.preserve_commit_hashes:
commit.message = self._hash_re.sub(self._translate_commit_hash,
commit.message)
if self._args.replace_message:
for literal, replacement in self._args.replace_message['literals']:
commit.message = commit.message.replace(literal, replacement)
for regex, replacement in self._args.replace_message['regexes']:
commit.message = regex.sub(replacement, commit.message)
if self._message_callback:
commit.message = self._message_callback(commit.message)
# Change the author & committer according to mailmap rules
args = self._args
if args.mailmap:
commit.author_name, commit.author_email = \
args.mailmap.translate(commit.author_name, commit.author_email)
commit.committer_name, commit.committer_email = \
args.mailmap.translate(commit.committer_name, commit.committer_email)
# Change author & committer according to callbacks
if self._name_callback:
commit.author_name = self._name_callback(commit.author_name)
commit.committer_name = self._name_callback(commit.committer_name)
if self._email_callback:
commit.author_email = self._email_callback(commit.author_email)
commit.committer_email = self._email_callback(commit.committer_email)
# Sometimes the 'branch' given is a tag; if so, rename it as requested so
# we don't get any old tagnames
if self._args.tag_rename:
commit.branch = RepoFilter._do_tag_rename(args.tag_rename, commit.branch)
if self._refname_callback:
commit.branch = self._refname_callback(commit.branch)
# Filter or rename the list of file changes
orig_file_changes = set(commit.file_changes)
self._filter_files(commit)
# Record ancestry graph
parents, orig_parents = commit.parents, aux_info['orig_parents']
if self._args.state_branch:
external_parents = parents
else:
external_parents = [p for p in parents if not isinstance(p, int)]
self._graph.record_external_commits(external_parents)
self._orig_graph.record_external_commits(external_parents)
self._graph.add_commit_and_parents(commit.id, parents)
self._orig_graph.add_commit_and_parents(commit.old_id, orig_parents)
# Prune parents (due to pruning of empty commits) if relevant
old_1st_parent = parents[0] if parents else None
parents, new_1st_parent = self._trim_extra_parents(orig_parents, parents)
commit.parents = parents
# If parents were pruned, then we need our file changes to be relative
# to the new first parent
if parents and old_1st_parent != parents[0]:
commit.file_changes = GitUtils.get_file_changes(self._repo_working_dir,
ID_TO_HASH[parents[0]],
commit.original_id)
orig_file_changes = set(commit.file_changes)
self._filter_files(commit)
# Find out which files were modified by the callbacks. Such paths could
# lead to subsequent commits being empty (e.g. if removing a line containing
# a password from every version of a file that had the password, and some
# later commit did nothing more than remove that line)
final_file_changes = set(commit.file_changes)
if self._args.replace_text or self._blob_callback:
differences = orig_file_changes.union(final_file_changes)
else:
differences = orig_file_changes.symmetric_difference(final_file_changes)
self._files_tweaked.update(x.filename for x in differences)
# Call the user-defined callback, if any
if self._commit_callback:
self._commit_callback(commit, self.callback_metadata(aux_info))
# Now print the resulting commit, or if prunable skip it
if not commit.dumped:
if not self._prunable(commit, new_1st_parent,
aux_info['had_file_changes'], orig_parents):
self._insert_into_stream(commit)
self._record_remapping(commit, orig_parents)
else:
rewrite_to = new_1st_parent or commit.first_parent()
commit.skip(new_id = rewrite_to)
if self._args.state_branch:
alias = Alias(commit.old_id or commit.id, rewrite_to or deleted_hash)
self._insert_into_stream(alias)
reset = Reset(commit.branch, rewrite_to or deleted_hash)
self._insert_into_stream(reset)
self._commit_renames[commit.original_id] = None
# Show progress
self._num_commits += 1
if not self._args.quiet:
self._progress_writer.show(self._parsed_message % self._num_commits)
@staticmethod
def _do_tag_rename(rename_pair, tagname):
old, new = rename_pair.split(b':', 1)
old, new = b'refs/tags/'+old, b'refs/tags/'+new
if tagname.startswith(old):
return tagname.replace(old, new, 1)
return tagname
def _tweak_tag(self, tag):
# Tweak the tag message according to callbacks
if self._args.replace_message:
for literal, replacement in self._args.replace_message['literals']:
tag.message = tag.message.replace(literal, replacement)
for regex, replacement in self._args.replace_message['regexes']:
tag.message = regex.sub(replacement, tag.message)
if self._message_callback:
tag.message = self._message_callback(tag.message)
# Tweak the tag name according to tag-name-related callbacks
tag_prefix = b'refs/tags/'
fullref = tag_prefix+tag.ref
if self._args.tag_rename:
fullref = RepoFilter._do_tag_rename(self._args.tag_rename, fullref)
if self._refname_callback:
fullref = self._refname_callback(fullref)
if not fullref.startswith(tag_prefix):
msg = "Error: fast-import requires tags to be in refs/tags/ namespace."
msg += "\n {} renamed to {}".format(tag_prefix+tag.ref, fullref)
raise SystemExit(msg)
tag.ref = fullref[len(tag_prefix):]
# Tweak the tagger according to callbacks
if self._args.mailmap:
tag.tagger_name, tag.tagger_email = \
self._args.mailmap.translate(tag.tagger_name, tag.tagger_email)
if self._name_callback:
tag.tagger_name = self._name_callback(tag.tagger_name)
if self._email_callback:
tag.tagger_email = self._email_callback(tag.tagger_email)
# Call general purpose tag callback
if self._tag_callback:
self._tag_callback(tag, self.callback_metadata())
def _tweak_reset(self, reset):
if self._args.tag_rename:
reset.ref = RepoFilter._do_tag_rename(self._args.tag_rename, reset.ref)
if self._refname_callback:
reset.ref = self._refname_callback(reset.ref)
if self._reset_callback:
self._reset_callback(reset, self.callback_metadata())
def results_tmp_dir(self, create_if_missing=True):
target_working_dir = self._args.target or b'.'
git_dir = GitUtils.determine_git_dir(target_working_dir)
d = os.path.join(git_dir, b'filter-repo')
if create_if_missing and not os.path.isdir(d):
os.mkdir(d)
return d
def _load_marks_file(self, marks_basename):
full_branch = 'refs/heads/{}'.format(self._args.state_branch)
marks_file = os.path.join(self.results_tmp_dir(), marks_basename)
working_dir = self._args.target or b'.'
cmd = ['git', '-C', working_dir, 'show-ref', full_branch]
contents = b''
if subproc.call(cmd, stdout=subprocess.DEVNULL) == 0:
cmd = ['git', '-C', working_dir, 'show',
'%s:%s' % (full_branch, decode(marks_basename))]
try:
contents = subproc.check_output(cmd)
except subprocess.CalledProcessError as e: # pragma: no cover
raise SystemExit(_("Failed loading %s from %s") %
(decode(marks_basename), full_branch))
if contents:
biggest_id = max(int(x.split()[0][1:]) for x in contents.splitlines())
_IDS._next_id = max(_IDS._next_id, biggest_id+1)
with open(marks_file, 'bw') as f:
f.write(contents)
return marks_file
def _save_marks_files(self):
basenames = [b'source-marks', b'target-marks']
working_dir = self._args.target or b'.'
# Check whether the branch exists
parent = []
full_branch = 'refs/heads/{}'.format(self._args.state_branch)
cmd = ['git', '-C', working_dir, 'show-ref', full_branch]
if subproc.call(cmd, stdout=subprocess.DEVNULL) == 0:
parent = ['-p', full_branch]
# Run 'git hash-object $MARKS_FILE' for each marks file, save result
blob_hashes = {}
for marks_basename in basenames:
marks_file = os.path.join(self.results_tmp_dir(), marks_basename)
if not os.path.isfile(marks_file): # pragma: no cover
raise SystemExit(_("Failed to find %s to save to %s")
% (marks_file, self._args.state_branch))
cmd = ['git', '-C', working_dir, 'hash-object', '-w', marks_file]
blob_hashes[marks_basename] = subproc.check_output(cmd).strip()
# Run 'git mktree' to create a tree out of it
p = subproc.Popen(['git', '-C', working_dir, 'mktree'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
for b in basenames:
p.stdin.write(b'100644 blob %s\t%s\n' % (blob_hashes[b], b))
p.stdin.close()
p.wait()
tree = p.stdout.read().strip()
# Create the new commit
cmd = (['git', '-C', working_dir, 'commit-tree', '-m', 'New mark files',
tree] + parent)
commit = subproc.check_output(cmd).strip()
subproc.call(['git', '-C', working_dir, 'update-ref', full_branch, commit])
def importer_only(self):
self._run_sanity_checks()
self._setup_output()
def set_output(self, outputRepoFilter):
assert outputRepoFilter._output
# set_output implies this RepoFilter is doing exporting, though may not
# be the only one.
self._setup_input(use_done_feature = False)
# Set our output management up to pipe to outputRepoFilter's locations
self._managed_output = False
self._output = outputRepoFilter._output
self._import_pipes = outputRepoFilter._import_pipes
# Handle sanity checks, though currently none needed for export-only cases
self._run_sanity_checks()
def _setup_input(self, use_done_feature):
if self._args.stdin:
self._input = sys.stdin.detach()
sys.stdin = None # Make sure no one tries to accidentally use it
self._fe_orig = None
else:
skip_blobs = (self._blob_callback is None and
self._args.replace_text is None and
self._args.source == self._args.target)
extra_flags = []
if skip_blobs:
extra_flags.append('--no-data')
if self._args.max_blob_size:
self._unpacked_size, packed_size = GitUtils.get_blob_sizes()
if use_done_feature:
extra_flags.append('--use-done-feature')
if write_marks:
extra_flags.append(b'--mark-tags')
if self._args.state_branch:
assert(write_marks)
source_marks_file = self._load_marks_file(b'source-marks')
extra_flags.extend([b'--export-marks='+source_marks_file,
b'--import-marks='+source_marks_file])
if self._args.preserve_commit_encoding is not None: # pragma: no cover
reencode = 'no' if self._args.preserve_commit_encoding else 'yes'
extra_flags.append('--reencode='+reencode)
location = ['-C', self._args.source] if self._args.source else []
fep_cmd = ['git'] + location + ['fast-export', '--show-original-ids',
'--signed-tags=strip', '--tag-of-filtered-object=rewrite',
'--fake-missing-tagger', '--reference-excluded-parents'
] + extra_flags + self._args.refs
self._fep = subproc.Popen(fep_cmd, bufsize=-1, stdout=subprocess.PIPE)
self._input = self._fep.stdout
if self._args.dry_run or self._args.debug:
self._fe_orig = os.path.join(self.results_tmp_dir(),
b'fast-export.original')
output = open(self._fe_orig, 'bw')
self._input = InputFileBackup(self._input, output)
if self._args.debug:
tmp = [decode(x) if isinstance(x, bytes) else x for x in fep_cmd]
print("[DEBUG] Running: {}".format(' '.join(tmp)))
print(" (saving a copy of the output at {})"
.format(decode(self._fe_orig)))
def _setup_output(self):
if not self._args.dry_run:
location = ['-C', self._args.target] if self._args.target else []
fip_cmd = ['git'] + location + ['-c', 'core.ignorecase=false',
'fast-import', '--force', '--quiet']
if date_format_permissive:
fip_cmd.append('--date-format=raw-permissive')
if self._args.state_branch:
target_marks_file = self._load_marks_file(b'target-marks')
fip_cmd.extend([b'--export-marks='+target_marks_file,
b'--import-marks='+target_marks_file])
self._fip = subproc.Popen(fip_cmd, bufsize=-1,
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
self._import_pipes = (self._fip.stdin, self._fip.stdout)
if self._args.dry_run or self._args.debug:
self._fe_filt = os.path.join(self.results_tmp_dir(),
b'fast-export.filtered')
self._output = open(self._fe_filt, 'bw')
else:
self._output = self._fip.stdin
if self._args.debug and not self._args.dry_run:
self._output = DualFileWriter(self._fip.stdin, self._output)
tmp = [decode(x) if isinstance(x, bytes) else x for x in fip_cmd]
print("[DEBUG] Running: {}".format(' '.join(tmp)))
print(" (using the following file as input: {})"
.format(decode(self._fe_filt)))
def _migrate_origin_to_heads(self):
refs_to_migrate = set(x for x in self._orig_refs
if x.startswith(b'refs/remotes/origin/'))
if not refs_to_migrate:
return
if self._args.debug:
print("[DEBUG] Migrating refs/remotes/origin/* -> refs/heads/*")
target_working_dir = self._args.target or b'.'
p = subproc.Popen('git update-ref --no-deref --stdin'.split(),
stdin=subprocess.PIPE, cwd=target_working_dir)
for ref in refs_to_migrate:
if ref == b'refs/remotes/origin/HEAD':
p.stdin.write(b'delete %s %s\n' % (ref, self._orig_refs[ref]))
del self._orig_refs[ref]
continue
newref = ref.replace(b'refs/remotes/origin/', b'refs/heads/')
if newref not in self._orig_refs:
p.stdin.write(b'create %s %s\n' % (newref, self._orig_refs[ref]))
p.stdin.write(b'delete %s %s\n' % (ref, self._orig_refs[ref]))
self._orig_refs[newref] = self._orig_refs[ref]
del self._orig_refs[ref]
p.stdin.close()
if p.wait():
raise SystemExit(_("git update-ref failed; see above")) # pragma: no cover
# Now remove
if self._args.debug:
print("[DEBUG] Removing 'origin' remote (rewritten history will no ")
print(" longer be related; consider re-pushing it elsewhere.")
subproc.call('git remote rm origin'.split(), cwd=target_working_dir)
def _final_commands(self):
self._finalize_handled = True
self._done_callback and self._done_callback()
if not self._args.quiet:
self._progress_writer.finish()
def _ref_update(self, target_working_dir):
# Start the update-ref process
p = subproc.Popen('git update-ref --no-deref --stdin'.split(),
stdin=subprocess.PIPE,
cwd=target_working_dir)
# Remove replace_refs from _orig_refs
replace_refs = {k:v for k, v in self._orig_refs.items()
if k.startswith(b'refs/replace/')}
reverse_replace_refs = collections.defaultdict(list)
for k,v in replace_refs.items():
reverse_replace_refs[v].append(k)
all(map(self._orig_refs.pop, replace_refs))
# Remove unused refs
exported_refs, imported_refs = self.get_exported_and_imported_refs()
refs_to_nuke = exported_refs - imported_refs
if self._args.partial:
refs_to_nuke = set()
if refs_to_nuke and self._args.debug:
print("[DEBUG] Deleting the following refs:\n "+
decode(b"\n ".join(refs_to_nuke)))
p.stdin.write(b''.join([b"delete %s\n" % x
for x in refs_to_nuke]))
# Delete or update and add replace_refs; note that fast-export automatically
# handles 'update-no-add', we only need to take action for the other four
# choices for replace_refs.
self._flush_renames()
actual_renames = {k:v for k,v in self._commit_renames.items() if k != v}
if self._args.replace_refs in ['delete-no-add', 'delete-and-add']:
# Delete old replace refs, if unwanted
replace_refs_to_nuke = set(replace_refs)
if self._args.replace_refs == 'delete-and-add':
# git-update-ref won't allow us to update a ref twice, so be careful
# to avoid deleting refs we'll later update
replace_refs_to_nuke = replace_refs_to_nuke.difference(
[b'refs/replace/'+x for x in actual_renames])
p.stdin.write(b''.join([b"delete %s\n" % x
for x in replace_refs_to_nuke]))
if self._args.replace_refs in ['delete-and-add', 'update-or-add',
'update-and-add']:
# Add new replace refs
update_only = (self._args.replace_refs == 'update-or-add')
p.stdin.write(b''.join([b"update refs/replace/%s %s\n" % (old, new)
for old,new in actual_renames.items()
if new and not (update_only and
old in reverse_replace_refs)]))
# Complete the update-ref process
p.stdin.close()
if p.wait():
raise SystemExit(_("git update-ref failed; see above")) # pragma: no cover
def _record_metadata(self, metadata_dir, orig_refs):
self._flush_renames()
with open(os.path.join(metadata_dir, b'commit-map'), 'bw') as f:
f.write(("%-40s %s\n" % (_("old"), _("new"))).encode())
for (old,new) in self._commit_renames.items():
msg = b'%s %s\n' % (old, new if new != None else deleted_hash)
f.write(msg)
exported_refs, imported_refs = self.get_exported_and_imported_refs()
batch_check_process = None
batch_check_output_re = re.compile(b'^([0-9a-f]{40}) ([a-z]+) ([0-9]+)$')
with open(os.path.join(metadata_dir, b'ref-map'), 'bw') as f:
f.write(("%-40s %-40s %s\n" % (_("old"), _("new"), _("ref"))).encode())
for refname, old_hash in orig_refs.items():
if refname not in exported_refs:
continue
if refname not in imported_refs:
new_hash = deleted_hash
elif old_hash in self._commit_renames:
new_hash = self._commit_renames[old_hash]
new_hash = new_hash if new_hash != None else deleted_hash
else: # Must be either an annotated tag, or a ref whose tip was pruned
if not batch_check_process:
cmd = 'git cat-file --batch-check'.split()
target_working_dir = self._args.target or b'.'
batch_check_process = subproc.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
cwd=target_working_dir)
batch_check_process.stdin.write(refname+b"\n")
batch_check_process.stdin.flush()
line = batch_check_process.stdout.readline()
m = batch_check_output_re.match(line)
if m and m.group(2) in (b'tag', b'commit'):
new_hash = m.group(1)
elif line.endswith(b' missing\n'):
new_hash = deleted_hash
else:
raise SystemExit(_("Failed to find new id for %(refname)s "
"(old id was %(old_hash)s)")
% ({'refname': refname, 'old_hash': old_hash})
) # pragma: no cover
f.write(b'%s %s %s\n' % (old_hash, new_hash, refname))
if self._args.source or self._args.target:
new_refs = GitUtils.get_refs(self._args.target or b'.')
for ref, new_hash in new_refs.items():
if ref not in orig_refs and not ref.startswith(b'refs/replace/'):
old_hash = b'0'*len(new_hash)
f.write(b'%s %s %s\n' % (old_hash, new_hash, ref))
if batch_check_process:
batch_check_process.stdin.close()
batch_check_process.wait()
with open(os.path.join(metadata_dir, b'suboptimal-issues'), 'bw') as f:
issues_found = False
if self._commits_no_longer_merges:
issues_found = True
f.write(textwrap.dedent(_('''
The following commits used to be merge commits but due to filtering
are now regular commits; they likely have suboptimal commit messages
(e.g. "Merge branch next into master"). Original commit hash on the
left, commit hash after filtering/rewriting on the right:
''')[1:]).encode())
for oldhash, newhash in self._commits_no_longer_merges:
f.write(' {} {}\n'.format(oldhash, newhash).encode())
f.write(b'\n')
if self._commits_referenced_but_removed:
issues_found = True
f.write(textwrap.dedent(_('''
The following commits were filtered out, but referenced in another
commit message. The reference to the now-nonexistent commit hash
(or a substring thereof) was left as-is in any commit messages:
''')[1:]).encode())
for bad_commit_reference in self._commits_referenced_but_removed:
f.write(' {}\n'.format(bad_commit_reference).encode())
f.write(b'\n')
if not issues_found:
f.write(_("No filtering problems encountered.\n").encode())
with open(os.path.join(metadata_dir, b'already_ran'), 'bw') as f:
f.write(_("This file exists to allow you to filter again without --force.\n").encode())
def finish(self):
''' Alternative to run() when there is no input of our own to parse,
meaning that run only really needs to close the handle to fast-import
and let it finish, thus making a call to "run" feel like a misnomer. '''
assert not self._input
assert self._managed_output
self.run()
def insert(self, obj, direct_insertion = False):
if not direct_insertion:
if type(obj) == Blob:
self._tweak_blob(obj)
elif type(obj) == Commit:
aux_info = {'orig_parents': obj.parents,
'had_file_changes': bool(obj.file_changes)}
self._tweak_commit(obj, aux_info)
elif type(obj) == Reset:
self._tweak_reset(obj)
elif type(obj) == Tag:
self._tweak_tag(obj)
self._insert_into_stream(obj)
def _insert_into_stream(self, obj):
if not obj.dumped:
if self._parser:
self._parser.insert(obj)
else:
obj.dump(self._output)
def get_exported_and_imported_refs(self):
return self._parser.get_exported_and_imported_refs()
def run(self):
start = time.time()
if not self._input and not self._output:
self._run_sanity_checks()
if not self._args.dry_run and not self._args.partial:
self._migrate_origin_to_heads()
self._setup_input(use_done_feature = True)
self._setup_output()
assert self._sanity_checks_handled
if self._input:
# Create and run the filter
self._repo_working_dir = self._args.source or b'.'
self._parser = FastExportParser(blob_callback = self._tweak_blob,
commit_callback = self._tweak_commit,
tag_callback = self._tweak_tag,
reset_callback = self._tweak_reset,
done_callback = self._final_commands)
self._parser.run(self._input, self._output)
if not self._finalize_handled:
self._final_commands()
# Make sure fast-export completed successfully
if not self._args.stdin and self._fep.wait():
raise SystemExit(_("Error: fast-export failed; see above.")) # pragma: no cover
self._input.close()
# If we're not the manager of self._output, we should avoid post-run cleanup
if not self._managed_output:
return
# Close the output and ensure fast-import successfully completes
self._output.close()
if not self._args.dry_run and self._fip.wait():
raise SystemExit(_("Error: fast-import failed; see above.")) # pragma: no cover
# With fast-export and fast-import complete, update state if requested
if self._args.state_branch:
self._save_marks_files()
# Notify user how long it took, before doing a gc and such
msg = "New history written in {:.2f} seconds..."
if self._args.repack:
msg = "New history written in {:.2f} seconds; now repacking/cleaning..."
print(msg.format(time.time()-start))
# Exit early, if requested
if self._args.dry_run:
print(_("NOTE: Not running fast-import or cleaning up; --dry-run passed."))
if self._fe_orig:
print(_(" Requested filtering can be seen by comparing:"))
print(" " + decode(self._fe_orig))
else:
print(_(" Requested filtering can be seen at:"))
print(" " + decode(self._fe_filt))
return
target_working_dir = self._args.target or b'.'
if self._input:
self._ref_update(target_working_dir)
# Write out data about run
self._record_metadata(self.results_tmp_dir(), self._orig_refs)
# Final cleanup:
# If we need a repack, then nuke the reflogs and repack.
# If we need a reset, do a reset --hard
reset = not GitUtils.is_repository_bare(target_working_dir)
RepoFilter.cleanup(target_working_dir, self._args.repack, reset,
run_quietly=self._args.quiet,
show_debuginfo=self._args.debug)
# Let user know how long it took
print(_("Completely finished after {:.2f} seconds.")
.format(time.time()-start))
def main():
setup_gettext()
args = FilteringOptions.parse_args(sys.argv[1:])
if args.analyze:
RepoAnalyze.run(args)
else:
filter = RepoFilter(args)
filter.run()
if __name__ == '__main__':
main()
Reference in New Issue View Git Blame Copy Permalink