You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

JGitText.properties 39KB

Support creating pack bitmap indexes in PackWriter. Update the PackWriter to support writing out pack bitmap indexes, a parallel ".bitmap" file to the ".pack" file. Bitmaps are selected at commits every 1 to 5,000 commits for each unique path from the start. The most recent 100 commits are all bitmapped. The next 19,000 commits have a bitmaps every 100 commits. The remaining commits have a bitmap every 5,000 commits. Commits with more than 1 parent are prefered over ones with 1 or less. Furthermore, previously computed bitmaps are reused, if the previous entry had the reuse flag set, which is set when the bitmap was placed at the max allowed distance. Bitmaps are used to speed up the counting phase when packing, for requests that are not shallow. The PackWriterBitmapWalker uses a RevFilter to proactively mark commits with RevFlag.SEEN, when they appear in a bitmap. The walker produces the full closure of reachable ObjectIds, given the collection of starting ObjectIds. For fetch request, two ObjectWalks are executed to compute the ObjectIds reachable from the haves and from the wants. The ObjectIds needed to be written are determined by taking all the resulting wants AND NOT the haves. For clone requests, we get cached pack support for "free" since it is possible to determine if all of the ObjectIds in a pack file are included in the resulting list of ObjectIds to write. On my machine, the best times for clones and fetches of the linux kernel repository (with about 2.6M objects and 300K commits) are tabulated below: Operation Index V2 Index VE003 Clone 37530ms (524.06 MiB) 82ms (524.06 MiB) Fetch (1 commit back) 75ms 107ms Fetch (10 commits back) 456ms (269.51 KiB) 341ms (265.19 KiB) Fetch (100 commits back) 449ms (269.91 KiB) 337ms (267.28 KiB) Fetch (1000 commits back) 2229ms ( 14.75 MiB) 189ms ( 14.42 MiB) Fetch (10000 commits back) 2177ms ( 16.30 MiB) 254ms ( 15.88 MiB) Fetch (100000 commits back) 14340ms (185.83 MiB) 1655ms (189.39 MiB) Change-Id: Icdb0cdd66ff168917fb9ef17b96093990cc6a98d
11 years ago
blame: Compute the origin of lines in a result file BlameGenerator digs through history and discovers the origin of each line of some result file. BlameResult consumes the stream of regions created by the generator and lays them out in a table for applications to display alongside of source lines. Applications may optionally push in the working tree copy of a file using the push(String, byte[]) method, allowing the application to receive accurate line annotations for the working tree version. Lines that are uncommitted (difference between HEAD and working tree) will show up with the description given by the application as the author, or "Not Committed Yet" as a default string. Applications may also run the BlameGenerator in reverse mode using the reverse(AnyObjectId, AnyObjectId) method instead of push(). When running in the reverse mode the generator annotates lines by the commit they are removed in, rather than the commit they were added in. This allows a user to discover where a line disappeared from when they are looking at an older revision in the repository. For example: blame --reverse 16e810b2..master -L 1080, org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/RefDirectoryTest.java ( 1080) } 2302a6d3 (Christian Halstrick 2011-05-20 11:18:20 +0200 1081) 2302a6d3 (Christian Halstrick 2011-05-20 11:18:20 +0200 1082) /** 2302a6d3 (Christian Halstrick 2011-05-20 11:18:20 +0200 1083) * Kick the timestamp of a local file. Above we learn that line 1080 (a closing curly brace of the prior method) still exists in branch master, but the Javadoc comment below it has been removed by Christian Halstrick on May 20th as part of commit 2302a6d3. This result differs considerably from that of C Git's blame --reverse feature. JGit tells the reader which commit performed the delete, while C Git tells the reader the last commit that still contained the line, leaving it an exercise to the reader to discover the descendant that performed the removal. This is still only a basic implementation. Quite notably it is missing support for the smart block copy/move detection that the C implementation of `git blame` is well known for. Despite being incremental, the BlameGenerator can only be run once. After the generator runs it cannot be reused. A better implementation would support applications browsing through history efficiently. In regards to CQ 5110, only a little of the original code survives. CQ: 5110 Bug: 306161 Change-Id: I84b8ea4838bb7d25f4fcdd540547884704661b8f Signed-off-by: Kevin Sawicki <kevin@github.com> Signed-off-by: Shawn O. Pearce <spearce@spearce.org> Signed-off-by: Chris Aniszczyk <caniszczyk@gmail.com>
13 years ago
Support creating pack bitmap indexes in PackWriter. Update the PackWriter to support writing out pack bitmap indexes, a parallel ".bitmap" file to the ".pack" file. Bitmaps are selected at commits every 1 to 5,000 commits for each unique path from the start. The most recent 100 commits are all bitmapped. The next 19,000 commits have a bitmaps every 100 commits. The remaining commits have a bitmap every 5,000 commits. Commits with more than 1 parent are prefered over ones with 1 or less. Furthermore, previously computed bitmaps are reused, if the previous entry had the reuse flag set, which is set when the bitmap was placed at the max allowed distance. Bitmaps are used to speed up the counting phase when packing, for requests that are not shallow. The PackWriterBitmapWalker uses a RevFilter to proactively mark commits with RevFlag.SEEN, when they appear in a bitmap. The walker produces the full closure of reachable ObjectIds, given the collection of starting ObjectIds. For fetch request, two ObjectWalks are executed to compute the ObjectIds reachable from the haves and from the wants. The ObjectIds needed to be written are determined by taking all the resulting wants AND NOT the haves. For clone requests, we get cached pack support for "free" since it is possible to determine if all of the ObjectIds in a pack file are included in the resulting list of ObjectIds to write. On my machine, the best times for clones and fetches of the linux kernel repository (with about 2.6M objects and 300K commits) are tabulated below: Operation Index V2 Index VE003 Clone 37530ms (524.06 MiB) 82ms (524.06 MiB) Fetch (1 commit back) 75ms 107ms Fetch (10 commits back) 456ms (269.51 KiB) 341ms (265.19 KiB) Fetch (100 commits back) 449ms (269.91 KiB) 337ms (267.28 KiB) Fetch (1000 commits back) 2229ms ( 14.75 MiB) 189ms ( 14.42 MiB) Fetch (10000 commits back) 2177ms ( 16.30 MiB) 254ms ( 15.88 MiB) Fetch (100000 commits back) 14340ms (185.83 MiB) 1655ms (189.39 MiB) Change-Id: Icdb0cdd66ff168917fb9ef17b96093990cc6a98d
11 years ago
PackWriter: Support reuse of entire packs The most expensive part of packing a repository for transport to another system is enumerating all of the objects in the repository. Once this gets to the size of the linux-2.6 repository (1.8 million objects), enumeration can take several CPU minutes and costs a lot of temporary working set memory. Teach PackWriter to efficiently reuse an existing "cached pack" by answering a clone request with a thin pack followed by a larger cached pack appended to the end. This requires the repository owner to first construct the cached pack by hand, and record the tip commits inside of $GIT_DIR/objects/info/cached-packs: cd $GIT_DIR root=$(git rev-parse master) tmp=objects/.tmp-$$ names=$(echo $root | git pack-objects --keep-true-parents --revs $tmp) for n in $names; do chmod a-w $tmp-$n.pack $tmp-$n.idx touch objects/pack/pack-$n.keep mv $tmp-$n.pack objects/pack/pack-$n.pack mv $tmp-$n.idx objects/pack/pack-$n.idx done (echo "+ $root"; for n in $names; do echo "P $n"; done; echo) >>objects/info/cached-packs git repack -a -d When a clone request needs to include $root, the corresponding cached pack will be copied as-is, rather than enumerating all of the objects that are reachable from $root. For a linux-2.6 kernel repository that should be about 376 MiB, the above process creates two packs of 368 MiB and 38 MiB[1]. This is a local disk usage increase of ~26 MiB, due to reduced delta compression between the large cached pack and the smaller recent activity pack. The overhead is similar to 1 full copy of the compressed project sources. With this cached pack in hand, JGit daemon completes a clone request in 1m17s less time, but a slightly larger data transfer (+2.39 MiB): Before: remote: Counting objects: 1861830, done remote: Finding sources: 100% (1861830/1861830) remote: Getting sizes: 100% (88243/88243) remote: Compressing objects: 100% (88184/88184) Receiving objects: 100% (1861830/1861830), 376.01 MiB | 19.01 MiB/s, done. remote: Total 1861830 (delta 4706), reused 1851053 (delta 1553844) Resolving deltas: 100% (1564621/1564621), done. real 3m19.005s After: remote: Counting objects: 1601, done remote: Counting objects: 1828460, done remote: Finding sources: 100% (50475/50475) remote: Getting sizes: 100% (18843/18843) remote: Compressing objects: 100% (7585/7585) remote: Total 1861830 (delta 2407), reused 1856197 (delta 37510) Receiving objects: 100% (1861830/1861830), 378.40 MiB | 31.31 MiB/s, done. Resolving deltas: 100% (1559477/1559477), done. real 2m2.938s Repository owners can periodically refresh their cached packs by repacking their repository, folding all newer objects into a larger cached pack. Since repacking is already considered to be a normal Git maintenance activity, this isn't a very big burden. [1] In this test $root was set back about two weeks. Change-Id: Ib87131d5c4b5e8c5cacb0f4fe16ff4ece554734b Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
13 years ago
Added read/write support for pack bitmap index. A pack bitmap index is an additional index of compressed bitmaps of the object graph. Furthermore, a logical API of the index functionality is included, as it is expected to be used by the PackWriter. Compressed bitmaps are created using the javaewah library, which is a word-aligned compressed variant of the Java bitset class based on run-length encoding. The library only works with positive integer values. Thus, the maximum number of ObjectIds in a pack file that this index can currently support is limited to Integer.MAX_VALUE. Every ObjectId is given an integer mapping. The integer is the position of the ObjectId in the complete ObjectId list, sorted by offset, for the pack file. That integer is what the bitmaps use to reference the ObjectId. Currently, the new index format can only be used with pack files that contain a complete closure of the object graph e.g. the result of a garbage collection. The index file includes four bitmaps for the Git object types i.e. commits, trees, blobs, and tags. In addition, a collection of bitmaps keyed by an ObjectId is also included. The bitmap for each entry in the collection represents the full closure of ObjectIds reachable from the keyed ObjectId (including the keyed ObjectId itself). The bitmaps are further compressed by XORing the current bitmaps against prior bitmaps in the index, and selecting the smallest representation. The XOR'd bitmap and offset from the current entry to the position of the bitmap to XOR against is the actual representation of the entry in the index file. Each entry contains one byte, which is currently used to note whether the bitmap should be blindly reused. Change-Id: Id328724bf6b4c8366a088233098c18643edcf40f
11 years ago
Merging Git notes Merging Git notes branches has several differences from merging "normal" branches. Although Git notes are initially stored as one flat tree the tree may fanout when the number of notes becomes too large for efficient access. In this case the first two hex digits of the note name will be used as a subdirectory name and the rest 38 hex digits as the file name under that directory. Similarly, when number of notes decreases a fanout tree may collapse back into a flat tree. The Git notes merge algorithm must take into account possibly different tree structures in different note branches and must properly match them against each other. Any conflict on a Git note is, by default, resolved by concatenating the two conflicting versions of the note. A delete-edit conflict is, by default, resolved by keeping the edit version. The note merge logic is pluggable and the caller may provide custom note merger that will perform different merging strategy. Additionally, it is possible to have non-note entries inside a notes tree. The merge algorithm must also take this fact into account and will try to merge such non-note entries. However, in case of any merge conflicts the merge operation will fail. Git notes merge algorithm is currently not trying to do content merge of non-note entries. Thanks to Shawn Pearce for patiently answering my questions related to this topic, giving hints and providing code snippets. Change-Id: I3b2335c76c766fd7ea25752e54087f9b19d69c88 Signed-off-by: Sasa Zivkov <sasa.zivkov@sap.com> Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
13 years ago
Added read/write support for pack bitmap index. A pack bitmap index is an additional index of compressed bitmaps of the object graph. Furthermore, a logical API of the index functionality is included, as it is expected to be used by the PackWriter. Compressed bitmaps are created using the javaewah library, which is a word-aligned compressed variant of the Java bitset class based on run-length encoding. The library only works with positive integer values. Thus, the maximum number of ObjectIds in a pack file that this index can currently support is limited to Integer.MAX_VALUE. Every ObjectId is given an integer mapping. The integer is the position of the ObjectId in the complete ObjectId list, sorted by offset, for the pack file. That integer is what the bitmaps use to reference the ObjectId. Currently, the new index format can only be used with pack files that contain a complete closure of the object graph e.g. the result of a garbage collection. The index file includes four bitmaps for the Git object types i.e. commits, trees, blobs, and tags. In addition, a collection of bitmaps keyed by an ObjectId is also included. The bitmap for each entry in the collection represents the full closure of ObjectIds reachable from the keyed ObjectId (including the keyed ObjectId itself). The bitmaps are further compressed by XORing the current bitmaps against prior bitmaps in the index, and selecting the smallest representation. The XOR'd bitmap and offset from the current entry to the position of the bitmap to XOR against is the actual representation of the entry in the index file. Each entry contains one byte, which is currently used to note whether the bitmap should be blindly reused. Change-Id: Id328724bf6b4c8366a088233098c18643edcf40f
11 years ago
Handle stale file handles on packed-refs file On a local filesystem the packed-refs file will be orphaned if it is replaced by another client while the current client is reading the old one. However, since NFS servers do not keep track of open files, instead of orphaning the old packed-refs file, such a replacement will cause the old file to be garbage collected instead. A stale file handle exception will be raised on NFS servers if the file is garbage collected (deleted) on the server while it is being read. Since we no longer have access to the old file in these cases, the previous code would just fail. However, in these cases, reopening the file and rereading it will succeed (since it will reopen the new replacement file). So retrying the read is a viable strategy to deal with stale file handles on the packed-refs file, implement such a strategy. Since it is possible that the packed-refs file could be replaced again while rereading it (multiple consecutive updates can easily occur with ref deletions), loop on stale file handle exceptions, up to 5 extra times, trying to read the packed-refs file again, until we either read the new file, or find that the file no longer exists. The limit of 5 is arbitrary, and provides a safe upper bounds to prevent infinite loops consuming resources in a potential unforeseen persistent error condition. Change-Id: I085c472bafa6e2f32f610a33ddc8368bb4ab1814 Signed-off-by: Martin Fick<mfick@codeaurora.org> Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
8 years ago
Rewrite push certificate parsing - Consistently return structured data, such as actual ReceiveCommands, which is more useful for callers that are doing things other than verifying the signature, e.g. recording the set of commands. - Store the certificate version field, as this is required to be part of the signed payload. - Add a toText() method to recreate the actual payload for signature verification. This requires keeping track of the un-chomped command strings from the original protocol stream. - Separate the parser from the certificate itself, so the actual PushCertificate object can be immutable. Make a fair attempt at deep immutability, but this is not possible with the current mutable ReceiveCommand structure. - Use more detailed error messages that don't involve NON-NLS strings. - Document null return values more thoroughly. Instead of having the undocumented behavior of throwing NPE from certain methods if they are not first guarded by enabled(), eliminate enabled() and return null from those methods. - Add tests for parsing a push cert from a section of pkt-line stream using a real live stream captured with Wireshark (which, it should be noted, uncovered several simply incorrect statements in C git's Documentation/technical/pack-protocol.txt). This is a slightly breaking API change to classes that were technically public and technically released in 4.0. However, it is highly unlikely that people were actually depending on public behavior, since there were no public methods to create PushCertificates with anything other than null field values, or a PushCertificateParser that did anything other than infinite loop or throw exceptions when reading. Change-Id: I5382193347a8eb1811032d9b32af9651871372d0
9 years ago
maxObjectSizeLimit for receive-pack. ReceivePack (and PackParser) can be configured with the maxObjectSizeLimit in order to prevent users from pushing too large objects to Git. The limit check is applied to all object types although it is most likely that a BLOB will exceed the limit. In all cases the size of the object header is excluded from the object size which is checked against the limit as this is the size of which a BLOB object would take in the working tree when checked out as a file. When an object exceeds the maxObjectSizeLimit the receive-pack will abort immediately. Delta objects (both offset and ref delta) are also checked against the limit. However, for delta objects we will first check the size of the inflated delta block against the maxObjectSizeLimit and abort immediately if it exceeds the limit. In this case we even do not know the exact size of the resolved delta object but we assume it will be larger than the given maxObjectSizeLimit as delta is generally only chosen if the delta can copy more data from the base object than the delta needs to insert or needs to represent the copy ranges. Aborting early, in this case, avoids unnecessary inflating of the (huge) delta block. Unfortunately, it is too expensive (especially for a large delta) to compute SHA-1 of an object that causes the receive-pack to abort. This would decrease the value of this feature whose main purpose is to protect server resources from users pushing huge objects. Therefore we don't report the SHA-1 in the error message. Change-Id: I177ef24553faacda444ed5895e40ac8925ca0d1e Signed-off-by: Sasa Zivkov <sasa.zivkov@sap.com> Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
12 years ago
Implement similarity based rename detection Content similarity based rename detection is performed only after a linear time detection is performed using exact content match on the ObjectIds. Any names which were paired up during that exact match phase are excluded from the inexact similarity based rename, which reduces the space that must be considered. During rename detection two entries cannot be marked as a rename if they are different types of files. This prevents a symlink from being renamed to a regular file, even if their blob content appears to be similar, or is identical. Efficiently comparing two files is performed by building up two hash indexes and hashing lines or short blocks from each file, counting the number of bytes that each line or block represents. Instead of using a standard java.util.HashMap, we use a custom open hashing scheme similiar to what we use in ObjecIdSubclassMap. This permits us to have a very light-weight hash, with very little memory overhead per cell stored. As we only need two ints per record in the map (line/block key and number of bytes), we collapse them into a single long inside of a long array, making very efficient use of available memory when we create the index table. We only need object headers for the index structure itself, and the index table, but not per-cell. This offers a massive space savings over using java.util.HashMap. The score calculation is done by approximating how many bytes are the same between the two inputs (which for a delta would be how much is copied from the base into the result). The score is derived by dividing the approximate number of bytes in common into the length of the larger of the two input files. Right now the SimilarityIndex table should average about 1/2 full, which means we waste about 50% of our memory on empty entries after we are done indexing a file and sort the table's contents. If memory becomes an issue we could discard the table and copy all records over to a new array that is properly sized. Building the index requires O(M + N log N) time, where M is the size of the input file in bytes, and N is the number of unique lines/blocks in the file. The N log N time constraint comes from the sort of the index table that is necessary to perform linear time matching against another SimilarityIndex created for a different file. To actually perform the rename detection, a SxD matrix is created, placing the sources (aka deletions) along one dimension and the destinations (aka additions) along the other. A simple O(S x D) loop examines every cell in this matrix. A SimilarityIndex is built along the row and reused for each column compare along that row, avoiding the costly index rebuild at the row level. A future improvement would be to load a smaller square matrix into SimilarityIndexes and process everything in that sub-matrix before discarding the column dimension and moving down to the next sub-matrix block along that same grid of rows. An optional ProgressMonitor is permitted to be passed in, allowing applications to see the progress of the detector as it works through the matrix cells. This provides some indication of current status for very long running renames. The default line/block hash function used by the SimilarityIndex may not be optimal, and may produce too many collisions. It is borrowed from RawText's hash, which is used to quickly skip out of a longer equality test if two lines have different hash functions. We may need to refine this hash in the future, in order to minimize the number of collisions we get on common source files. Based on a handful of test commits in JGit (especially my own recent rename repository refactoring series), this rename detector produces output that is very close to C Git. The content similarity scores are sometimes off by 1%, which is most probably caused by our SimilarityIndex type using a different hash function than C Git uses when it computes the delta size between any two objects in the rename matrix. Bug: 318504 Change-Id: I11dff969e8a2e4cf252636d857d2113053bdd9dc Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
14 years ago
Increase core.streamFileThreshold default to 50 MiB Projects like org.eclipse.mdt contain large XML files about 6 MiB in size. So does the Android project platform/frameworks/base. Doing a clone of either project with JGit takes forever to checkout the files into the working directory, because delta decompression tends to be very expensive as we need to constantly reposition the base stream for each copy instruction. This can be made worse by a very bad ordering of offsets, possibly due to an XML editor that doesn't preserve the order of elements in the file very well. Increasing the threshold to the same limit PackWriter uses when doing delta compression (50 MiB) permits a default configured JGit to decompress these XML file objects using the faster random-access arrays, rather than re-seeking through an inflate stream, significantly reducing checkout time after a clone. Since this new limit may be dangerously close to the JVM maximum heap size, every allocation attempt is now wrapped in a try/catch so that JGit can degrade by switching to the large object stream mode when the allocation is refused. It will run slower, but the operation will still complete. The large stream mode will run very well for big objects that aren't delta compressed, and is acceptable for delta compressed objects that are using only forward referencing copy instructions. Copies using prior offsets are still going to be horrible, and there is nothing we can do about it except increase core.streamFileThreshold. We might in the future want to consider changing the way the delta generators work in JGit and native C Git to avoid prior offsets once an object reaches a certain size, even if that causes the delta instruction stream to be slightly larger. Unfortunately native C Git won't want to do that until its also able to stream objects rather than malloc them as contiguous blocks. Change-Id: Ief7a3896afce15073e80d3691bed90c6a3897307 Signed-off-by: Shawn O. Pearce <spearce@spearce.org> Signed-off-by: Chris Aniszczyk <caniszczyk@gmail.com>
13 years ago
Support creating pack bitmap indexes in PackWriter. Update the PackWriter to support writing out pack bitmap indexes, a parallel ".bitmap" file to the ".pack" file. Bitmaps are selected at commits every 1 to 5,000 commits for each unique path from the start. The most recent 100 commits are all bitmapped. The next 19,000 commits have a bitmaps every 100 commits. The remaining commits have a bitmap every 5,000 commits. Commits with more than 1 parent are prefered over ones with 1 or less. Furthermore, previously computed bitmaps are reused, if the previous entry had the reuse flag set, which is set when the bitmap was placed at the max allowed distance. Bitmaps are used to speed up the counting phase when packing, for requests that are not shallow. The PackWriterBitmapWalker uses a RevFilter to proactively mark commits with RevFlag.SEEN, when they appear in a bitmap. The walker produces the full closure of reachable ObjectIds, given the collection of starting ObjectIds. For fetch request, two ObjectWalks are executed to compute the ObjectIds reachable from the haves and from the wants. The ObjectIds needed to be written are determined by taking all the resulting wants AND NOT the haves. For clone requests, we get cached pack support for "free" since it is possible to determine if all of the ObjectIds in a pack file are included in the resulting list of ObjectIds to write. On my machine, the best times for clones and fetches of the linux kernel repository (with about 2.6M objects and 300K commits) are tabulated below: Operation Index V2 Index VE003 Clone 37530ms (524.06 MiB) 82ms (524.06 MiB) Fetch (1 commit back) 75ms 107ms Fetch (10 commits back) 456ms (269.51 KiB) 341ms (265.19 KiB) Fetch (100 commits back) 449ms (269.91 KiB) 337ms (267.28 KiB) Fetch (1000 commits back) 2229ms ( 14.75 MiB) 189ms ( 14.42 MiB) Fetch (10000 commits back) 2177ms ( 16.30 MiB) 254ms ( 15.88 MiB) Fetch (100000 commits back) 14340ms (185.83 MiB) 1655ms (189.39 MiB) Change-Id: Icdb0cdd66ff168917fb9ef17b96093990cc6a98d
11 years ago
Shallow fetch: Respect "shallow" lines When fetching from a shallow clone, the client sends "have" lines to tell the server about objects it already has and "shallow" lines to tell where its local history terminates. In some circumstances, the server fails to honor the shallow lines and fails to return objects that the client needs. UploadPack passes the "have" lines to PackWriter so PackWriter can omit them from the generated pack. UploadPack processes "shallow" lines by calling RevWalk.assumeShallow() with the set of shallow commits. RevWalk creates and caches RevCommits for these shallow commits, clearing out their parents. That way, walks correctly terminate at the shallow commits instead of assuming the client has history going back behind them. UploadPack converts its RevWalk to an ObjectWalk, maintaining the cached RevCommits, and passes it to PackWriter. Unfortunately, to support shallow fetches the PackWriter does the following: if (shallowPack && !(walk instanceof DepthWalk.ObjectWalk)) walk = new DepthWalk.ObjectWalk(reader, depth); That is, when the client sends a "deepen" line (fetch --depth=<n>) and the caller has not passed in a DepthWalk.ObjectWalk, PackWriter throws away the RevWalk that was passed in and makes a new one. The cleared parent lists prepared by RevWalk.assumeShallow() are lost. Fortunately UploadPack intends to pass in a DepthWalk.ObjectWalk. It tries to create it by calling toObjectWalkWithSameObjects() on a DepthWalk.RevWalk. But it doesn't work: because DepthWalk.RevWalk does not override the standard RevWalk#toObjectWalkWithSameObjects implementation, the result is a plain ObjectWalk instead of an instance of DepthWalk.ObjectWalk. The result is that the "shallow" information is thrown away and objects reachable from the shallow commits can be omitted from the pack sent when fetching with --depth from a shallow clone. Multiple factors collude to limit the circumstances under which this bug can be observed: 1. Commits with depth != 0 don't enter DepthGenerator's pending queue. That means a "have" cannot have any effect on DepthGenerator unless it is also a "want". 2. DepthGenerator#next() doesn't call carryFlagsImpl(), so the uninteresting flag is not propagated to ancestors there even if a "have" is also a "want". 3. JGit treats a depth of 1 as "1 past the wants". Because of (2), the only place the UNINTERESTING flag can leak to a shallow commit's parents is in the carryFlags() call from markUninteresting(). carryFlags() only traverses commits that have already been parsed: commits yet to be parsed are supposed to inherit correct flags from their parent in PendingGenerator#next (which doesn't happen here --- that is (2)). So the list of commits that have already been parsed becomes relevant. When we hit the markUninteresting() call, all "want"s, "have"s, and commits to be unshallowed have been parsed. carryFlags() only affects the parsed commits. If the "want" is a direct parent of a "have", then it carryFlags() marks it as uninteresting. If the "have" was also a "shallow", then its parent pointer should have been null and the "want" shouldn't have been marked, so we see the bug. If the "want" is a more distant ancestor then (2) keeps the uninteresting state from propagating to the "want" and we don't see the bug. If the "shallow" is not also a "have" then the shallow commit isn't parsed so (2) keeps the uninteresting state from propagating to the "want so we don't see the bug. Here is a reproduction case (time flowing left to right, arrows pointing to parents). "C" must be a commit that the client reports as a "have" during negotiation. That can only happen if the server reports it as an existing branch or tag in the first round of negotiation: A <-- B <-- C <-- D First do git clone --depth 1 <repo> which yields D as a "have" and C as a "shallow" commit. Then try git fetch --depth 1 <repo> B:refs/heads/B Negotiation sets up: have D, shallow C, have C, want B. But due to this bug B is marked as uninteresting and is not sent. Change-Id: I6e14b57b2f85e52d28cdcf356df647870f475440 Signed-off-by: Terry Parker <tparker@google.com>
7 years ago
Implement similarity based rename detection Content similarity based rename detection is performed only after a linear time detection is performed using exact content match on the ObjectIds. Any names which were paired up during that exact match phase are excluded from the inexact similarity based rename, which reduces the space that must be considered. During rename detection two entries cannot be marked as a rename if they are different types of files. This prevents a symlink from being renamed to a regular file, even if their blob content appears to be similar, or is identical. Efficiently comparing two files is performed by building up two hash indexes and hashing lines or short blocks from each file, counting the number of bytes that each line or block represents. Instead of using a standard java.util.HashMap, we use a custom open hashing scheme similiar to what we use in ObjecIdSubclassMap. This permits us to have a very light-weight hash, with very little memory overhead per cell stored. As we only need two ints per record in the map (line/block key and number of bytes), we collapse them into a single long inside of a long array, making very efficient use of available memory when we create the index table. We only need object headers for the index structure itself, and the index table, but not per-cell. This offers a massive space savings over using java.util.HashMap. The score calculation is done by approximating how many bytes are the same between the two inputs (which for a delta would be how much is copied from the base into the result). The score is derived by dividing the approximate number of bytes in common into the length of the larger of the two input files. Right now the SimilarityIndex table should average about 1/2 full, which means we waste about 50% of our memory on empty entries after we are done indexing a file and sort the table's contents. If memory becomes an issue we could discard the table and copy all records over to a new array that is properly sized. Building the index requires O(M + N log N) time, where M is the size of the input file in bytes, and N is the number of unique lines/blocks in the file. The N log N time constraint comes from the sort of the index table that is necessary to perform linear time matching against another SimilarityIndex created for a different file. To actually perform the rename detection, a SxD matrix is created, placing the sources (aka deletions) along one dimension and the destinations (aka additions) along the other. A simple O(S x D) loop examines every cell in this matrix. A SimilarityIndex is built along the row and reused for each column compare along that row, avoiding the costly index rebuild at the row level. A future improvement would be to load a smaller square matrix into SimilarityIndexes and process everything in that sub-matrix before discarding the column dimension and moving down to the next sub-matrix block along that same grid of rows. An optional ProgressMonitor is permitted to be passed in, allowing applications to see the progress of the detector as it works through the matrix cells. This provides some indication of current status for very long running renames. The default line/block hash function used by the SimilarityIndex may not be optimal, and may produce too many collisions. It is borrowed from RawText's hash, which is used to quickly skip out of a longer equality test if two lines have different hash functions. We may need to refine this hash in the future, in order to minimize the number of collisions we get on common source files. Based on a handful of test commits in JGit (especially my own recent rename repository refactoring series), this rename detector produces output that is very close to C Git. The content similarity scores are sometimes off by 1%, which is most probably caused by our SimilarityIndex type using a different hash function than C Git uses when it computes the delta size between any two objects in the rename matrix. Bug: 318504 Change-Id: I11dff969e8a2e4cf252636d857d2113053bdd9dc Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
14 years ago
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  1. #
  2. # Messages with format elements ({0}) are processed using java.text.MessageFormat.
  3. #
  4. abbreviationLengthMustBeNonNegative=Abbreviation length must not be negative.
  5. abortingRebase=Aborting rebase: resetting to {0}
  6. abortingRebaseFailed=Could not abort rebase
  7. abortingRebaseFailedNoOrigHead=Could not abort rebase since ORIG_HEAD is null
  8. advertisementCameBefore=advertisement of {0}^'{}' came before {1}
  9. advertisementOfCameBefore=advertisement of {0}^'{}' came before {1}
  10. amazonS3ActionFailed={0} of ''{1}'' failed: {2} {3}
  11. amazonS3ActionFailedGivingUp={0} of ''{1}'' failed: Giving up after {2} attempts.
  12. ambiguousObjectAbbreviation=Object abbreviation {0} is ambiguous
  13. aNewObjectIdIsRequired=A NewObjectId is required.
  14. anExceptionOccurredWhileTryingToAddTheIdOfHEAD=An exception occurred while trying to add the Id of HEAD
  15. anSSHSessionHasBeenAlreadyCreated=An SSH session has been already created
  16. applyingCommit=Applying {0}
  17. archiveFormatAlreadyAbsent=Archive format already absent: {0}
  18. archiveFormatAlreadyRegistered=Archive format already registered with different implementation: {0}
  19. argumentIsNotAValidCommentString=Invalid comment: {0}
  20. atLeastOnePathIsRequired=At least one path is required.
  21. atLeastOnePatternIsRequired=At least one pattern is required.
  22. atLeastTwoFiltersNeeded=At least two filters needed.
  23. atomicPushNotSupported=Atomic push not supported.
  24. atomicRefUpdatesNotSupported=Atomic ref updates not supported
  25. authenticationNotSupported=authentication not supported
  26. badBase64InputCharacterAt=Bad Base64 input character at {0} : {1} (decimal)
  27. badEntryDelimiter=Bad entry delimiter
  28. badEntryName=Bad entry name: {0}
  29. badEscape=Bad escape: {0}
  30. badGroupHeader=Bad group header
  31. badObjectType=Bad object type: {0}
  32. badRef=Bad ref: {0}: {1}
  33. badSectionEntry=Bad section entry: {0}
  34. bareRepositoryNoWorkdirAndIndex=Bare Repository has neither a working tree, nor an index
  35. base64InputNotProperlyPadded=Base64 input not properly padded.
  36. baseLengthIncorrect=base length incorrect
  37. bitmapMissingObject=Bitmap at {0} is missing {1}.
  38. bitmapsMustBePrepared=Bitmaps must be prepared before they may be written.
  39. blameNotCommittedYet=Not Committed Yet
  40. blobNotFound=Blob not found: {0}
  41. blobNotFoundForPath=Blob not found: {0} for path: {1}
  42. blockSizeNotPowerOf2=blockSize must be a power of 2
  43. branchNameInvalid=Branch name {0} is not allowed
  44. buildingBitmaps=Building bitmaps
  45. cachedPacksPreventsIndexCreation=Using cached packs prevents index creation
  46. cachedPacksPreventsListingObjects=Using cached packs prevents listing objects
  47. cannotBeCombined=Cannot be combined.
  48. cannotBeRecursiveWhenTreesAreIncluded=TreeWalk shouldn't be recursive when tree objects are included.
  49. cannotChangeActionOnComment=Cannot change action on comment line in git-rebase-todo file, old action: {0}, new action: {1}.
  50. cannotChangeToComment=Cannot change a non-comment line to a comment line.
  51. cannotCheckoutFromUnbornBranch=Cannot checkout from unborn branch
  52. cannotCheckoutOursSwitchBranch=Checking out ours/theirs is only possible when checking out index, not when switching branches.
  53. cannotCombineSquashWithNoff=Cannot combine --squash with --no-ff.
  54. cannotCombineTreeFilterWithRevFilter=Cannot combine TreeFilter {0} with RevFilter {1}.
  55. cannotCommitOnARepoWithState=Cannot commit on a repo with state: {0}
  56. cannotCommitWriteTo=Cannot commit write to {0}
  57. cannotConnectPipes=cannot connect pipes
  58. cannotConvertScriptToText=Cannot convert script to text
  59. cannotCreateConfig=cannot create config
  60. cannotCreateDirectory=Cannot create directory {0}
  61. cannotCreateHEAD=cannot create HEAD
  62. cannotCreateIndexfile=Cannot create an index file with name {0}
  63. cannotCreateTempDir=Cannot create a temp dir
  64. cannotDeleteCheckedOutBranch=Branch {0} is checked out and can not be deleted
  65. cannotDeleteFile=Cannot delete file: {0}
  66. cannotDeleteObjectsPath=Cannot delete {0}/{1}: {2}
  67. cannotDeleteStaleTrackingRef=Cannot delete stale tracking ref {0}
  68. cannotDeleteStaleTrackingRef2=Cannot delete stale tracking ref {0}: {1}
  69. cannotDetermineProxyFor=Cannot determine proxy for {0}
  70. cannotDownload=Cannot download {0}
  71. cannotEnterObjectsPath=Cannot enter {0}/objects: {1}
  72. cannotEnterPathFromParent=Cannot enter {0} from {1}: {2}
  73. cannotExecute=cannot execute: {0}
  74. cannotGet=Cannot get {0}
  75. cannotGetObjectsPath=Cannot get {0}/{1}: {2}
  76. cannotListObjectsPath=Cannot ls {0}/{1}: {2}
  77. cannotListPackPath=Cannot ls {0}/pack: {1}
  78. cannotListRefs=cannot list refs
  79. cannotLock=Cannot lock {0}
  80. cannotLockPackIn=Cannot lock pack in {0}
  81. cannotMatchOnEmptyString=Cannot match on empty string.
  82. cannotMkdirObjectPath=Cannot mkdir {0}/{1}: {2}
  83. cannotMoveIndexTo=Cannot move index to {0}
  84. cannotMovePackTo=Cannot move pack to {0}
  85. cannotOpenService=cannot open {0}
  86. cannotParseDate=The date specification "{0}" could not be parsed with the following formats: {1}
  87. cannotParseGitURIish=Cannot parse Git URI-ish
  88. cannotPullOnARepoWithState=Cannot pull into a repository with state: {0}
  89. cannotRead=Cannot read {0}
  90. cannotReadBlob=Cannot read blob {0}
  91. cannotReadCommit=Cannot read commit {0}
  92. cannotReadFile=Cannot read file {0}
  93. cannotReadHEAD=cannot read HEAD: {0} {1}
  94. cannotReadIndex=The index file {0} exists but cannot be read
  95. cannotReadObject=Cannot read object
  96. cannotReadObjectsPath=Cannot read {0}/{1}: {2}
  97. cannotReadTree=Cannot read tree {0}
  98. cannotRebaseWithoutCurrentHead=Can not rebase without a current HEAD
  99. cannotResolveLocalTrackingRefForUpdating=Cannot resolve local tracking ref {0} for updating.
  100. cannotSquashFixupWithoutPreviousCommit=Cannot {0} without previous commit.
  101. cannotStoreObjects=cannot store objects
  102. cannotResolveUniquelyAbbrevObjectId=Could not resolve uniquely the abbreviated object ID
  103. cannotUnloadAModifiedTree=Cannot unload a modified tree.
  104. cannotUpdateUnbornBranch=Cannot update unborn branch
  105. cannotWorkWithOtherStagesThanZeroRightNow=Cannot work with other stages than zero right now. Won't write corrupt index.
  106. cannotWriteObjectsPath=Cannot write {0}/{1}: {2}
  107. canOnlyCherryPickCommitsWithOneParent=Cannot cherry-pick commit ''{0}'' because it has {1} parents, only commits with exactly one parent are supported.
  108. canOnlyRevertCommitsWithOneParent=Cannot revert commit ''{0}'' because it has {1} parents, only commits with exactly one parent are supported
  109. commitDoesNotHaveGivenParent=The commit ''{0}'' does not have a parent number {1}.
  110. cantFindObjectInReversePackIndexForTheSpecifiedOffset=Can''t find object in (reverse) pack index for the specified offset {0}
  111. cantPassMeATree=Can't pass me a tree!
  112. channelMustBeInRange1_255=channel {0} must be in range [1, 255]
  113. characterClassIsNotSupported=The character class {0} is not supported.
  114. checkoutConflictWithFile=Checkout conflict with file: {0}
  115. checkoutConflictWithFiles=Checkout conflict with files: {0}
  116. checkoutUnexpectedResult=Checkout returned unexpected result {0}
  117. classCastNotA=Not a {0}
  118. cloneNonEmptyDirectory=Destination path "{0}" already exists and is not an empty directory
  119. closed=closed
  120. collisionOn=Collision on {0}
  121. commandRejectedByHook=Rejected by "{0}" hook.\n{1}
  122. commandWasCalledInTheWrongState=Command {0} was called in the wrong state
  123. commitAlreadyExists=exists {0}
  124. commitMessageNotSpecified=commit message not specified
  125. commitOnRepoWithoutHEADCurrentlyNotSupported=Commit on repo without HEAD currently not supported
  126. commitAmendOnInitialNotPossible=Amending is not possible on initial commit.
  127. compressingObjects=Compressing objects
  128. connectionFailed=connection failed
  129. connectionTimeOut=Connection time out: {0}
  130. contextMustBeNonNegative=context must be >= 0
  131. corruptionDetectedReReadingAt=Corruption detected re-reading at {0}
  132. corruptObjectBadDate=bad date
  133. corruptObjectBadEmail=bad email
  134. corruptObjectBadStream=bad stream
  135. corruptObjectBadStreamCorruptHeader=bad stream, corrupt header
  136. corruptObjectBadTimezone=bad time zone
  137. corruptObjectDuplicateEntryNames=duplicate entry names
  138. corruptObjectGarbageAfterSize=garbage after size
  139. corruptObjectIncorrectLength=incorrect length
  140. corruptObjectIncorrectSorting=incorrectly sorted
  141. corruptObjectInvalidEntryMode=invalid entry mode
  142. corruptObjectInvalidMode=invalid mode
  143. corruptObjectInvalidModeChar=invalid mode character
  144. corruptObjectInvalidModeStartsZero=mode starts with '0'
  145. corruptObjectInvalidMode2=invalid mode {0,number,#}
  146. corruptObjectInvalidMode3=invalid mode {0} for {1} ''{2}'' in {3}.
  147. corruptObjectInvalidName=invalid name '%s'
  148. corruptObjectInvalidNameAux=invalid name 'AUX'
  149. corruptObjectInvalidNameCon=invalid name 'CON'
  150. corruptObjectInvalidNameCom=invalid name 'COM%c'
  151. corruptObjectInvalidNameEnd=invalid name ends with '%c'
  152. corruptObjectInvalidNameIgnorableUnicode=invalid name '%s' contains ignorable Unicode characters
  153. corruptObjectInvalidNameInvalidUtf8=invalid name contains byte sequence ''{0}'' which is not a valid UTF-8 character
  154. corruptObjectInvalidNameLpt=invalid name 'LPT%c'
  155. corruptObjectInvalidNameNul=invalid name 'NUL'
  156. corruptObjectInvalidNamePrn=invalid name 'PRN'
  157. corruptObjectInvalidObject=invalid object
  158. corruptObjectInvalidParent=invalid parent
  159. corruptObjectInvalidTree=invalid tree
  160. corruptObjectInvalidType=invalid type
  161. corruptObjectInvalidType2=invalid type {0}
  162. corruptObjectMalformedHeader=malformed header: {0}
  163. corruptObjectMissingEmail=missing email
  164. corruptObjectNameContainsByte=name contains byte 0x%x
  165. corruptObjectNameContainsChar=name contains '%c'
  166. corruptObjectNameContainsNullByte=name contains byte 0x00
  167. corruptObjectNameContainsSlash=name contains '/'
  168. corruptObjectNameDot=invalid name '.'
  169. corruptObjectNameDotDot=invalid name '..'
  170. corruptObjectNameZeroLength=zero length name
  171. corruptObjectNegativeSize=negative size
  172. corruptObjectNoAuthor=no author
  173. corruptObjectNoCommitter=no committer
  174. corruptObjectNoHeader=no header
  175. corruptObjectNoObject=no object
  176. corruptObjectNoObjectHeader=no object header
  177. corruptObjectNoTaggerBadHeader=no tagger/bad header
  178. corruptObjectNoTaggerHeader=no tagger header
  179. corruptObjectNoTagHeader=no tag header
  180. corruptObjectNoTagName=no tag name
  181. corruptObjectNotree=no tree
  182. corruptObjectNotreeHeader=no tree header
  183. corruptObjectNoType=no type
  184. corruptObjectNoTypeHeader=no type header
  185. corruptObjectPackfileChecksumIncorrect=Packfile checksum incorrect.
  186. corruptObjectTruncatedInMode=truncated in mode
  187. corruptObjectTruncatedInName=truncated in name
  188. corruptObjectTruncatedInObjectId=truncated in object id
  189. corruptObjectZeroId=entry points to null SHA-1
  190. corruptUseCnt=close() called when useCnt is already zero
  191. couldNotCheckOutBecauseOfConflicts=Could not check out because of conflicts
  192. couldNotDeleteLockFileShouldNotHappen=Could not delete lock file. Should not happen
  193. couldNotDeleteTemporaryIndexFileShouldNotHappen=Could not delete temporary index file. Should not happen
  194. couldNotGetAdvertisedRef=Remote {0} did not advertise Ref for branch {1}. This Ref may not exist in the remote or may be hidden by permission settings.
  195. couldNotGetRepoStatistics=Could not get repository statistics
  196. couldNotLockHEAD=Could not lock HEAD
  197. couldNotReadIndexInOneGo=Could not read index in one go, only {0} out of {1} read
  198. couldNotReadObjectWhileParsingCommit=Could not read an object while parsing commit {0}
  199. couldNotRenameDeleteOldIndex=Could not rename delete old index
  200. couldNotRenameTemporaryFile=Could not rename temporary file {0} to new location {1}
  201. couldNotRenameTemporaryIndexFileToIndex=Could not rename temporary index file to index
  202. couldNotRewindToUpstreamCommit=Could not rewind to upstream commit
  203. couldNotURLEncodeToUTF8=Could not URL encode to UTF-8
  204. couldNotWriteFile=Could not write file {0}
  205. countingObjects=Counting objects
  206. corruptPack=Pack file {0} is corrupt, removing it from pack list
  207. createBranchFailedUnknownReason=Create branch failed for unknown reason
  208. createBranchUnexpectedResult=Create branch returned unexpected result {0}
  209. createNewFileFailed=Could not create new file {0}
  210. credentialPassword=Password
  211. credentialUsername=Username
  212. daemonAlreadyRunning=Daemon already running
  213. daysAgo={0} days ago
  214. deleteBranchUnexpectedResult=Delete branch returned unexpected result {0}
  215. deleteFileFailed=Could not delete file {0}
  216. deleteTagUnexpectedResult=Delete tag returned unexpected result {0}
  217. deletingNotSupported=Deleting {0} not supported.
  218. destinationIsNotAWildcard=Destination is not a wildcard.
  219. detachedHeadDetected=HEAD is detached
  220. dirCacheDoesNotHaveABackingFile=DirCache does not have a backing file
  221. dirCacheFileIsNotLocked=DirCache {0} not locked
  222. dirCacheIsNotLocked=DirCache is not locked
  223. DIRCChecksumMismatch=DIRC checksum mismatch
  224. DIRCExtensionIsTooLargeAt=DIRC extension {0} is too large at {1} bytes.
  225. DIRCExtensionNotSupportedByThisVersion=DIRC extension {0} not supported by this version.
  226. DIRCHasTooManyEntries=DIRC has too many entries.
  227. DIRCUnrecognizedExtendedFlags=Unrecognized extended flags: {0}
  228. dirtyFilesExist=Dirty files exist. Refusing to merge
  229. doesNotHandleMode=Does not handle mode {0} ({1})
  230. downloadCancelled=Download cancelled
  231. downloadCancelledDuringIndexing=Download cancelled during indexing
  232. duplicateAdvertisementsOf=duplicate advertisements of {0}
  233. duplicateRef=Duplicate ref: {0}
  234. duplicateRemoteRefUpdateIsIllegal=Duplicate remote ref update is illegal. Affected remote name: {0}
  235. duplicateStagesNotAllowed=Duplicate stages not allowed
  236. eitherGitDirOrWorkTreeRequired=One of setGitDir or setWorkTree must be called.
  237. emptyCommit=No changes
  238. emptyPathNotPermitted=Empty path not permitted.
  239. emptyRef=Empty ref: {0}
  240. encryptionError=Encryption error: {0}
  241. encryptionOnlyPBE=Encryption error: only password-based encryption (PBE) algorithms are supported.
  242. endOfFileInEscape=End of file in escape
  243. entryNotFoundByPath=Entry not found by path: {0}
  244. enumValueNotSupported2=Invalid value: {0}.{1}={2}
  245. enumValueNotSupported3=Invalid value: {0}.{1}.{2}={3}
  246. enumValuesNotAvailable=Enumerated values of type {0} not available
  247. errorDecodingFromFile=Error decoding from file {0}
  248. errorEncodingFromFile=Error encoding from file {0}
  249. errorInBase64CodeReadingStream=Error in Base64 code reading stream.
  250. errorInPackedRefs=error in packed-refs
  251. errorInvalidProtocolWantedOldNewRef=error: invalid protocol: wanted 'old new ref'
  252. errorListing=Error listing {0}
  253. errorOccurredDuringUnpackingOnTheRemoteEnd=error occurred during unpacking on the remote end: {0}
  254. errorReadingInfoRefs=error reading info/refs
  255. exceptionCaughtDuringExecutionOfHook=Exception caught during execution of "{0}" hook.
  256. exceptionCaughtDuringExecutionOfAddCommand=Exception caught during execution of add command
  257. exceptionCaughtDuringExecutionOfArchiveCommand=Exception caught during execution of archive command
  258. exceptionCaughtDuringExecutionOfCherryPickCommand=Exception caught during execution of cherry-pick command. {0}
  259. exceptionCaughtDuringExecutionOfCommitCommand=Exception caught during execution of commit command
  260. exceptionCaughtDuringExecutionOfFetchCommand=Exception caught during execution of fetch command
  261. exceptionCaughtDuringExecutionOfLsRemoteCommand=Exception caught during execution of ls-remote command
  262. exceptionCaughtDuringExecutionOfMergeCommand=Exception caught during execution of merge command. {0}
  263. exceptionCaughtDuringExecutionOfPullCommand=Exception caught during execution of pull command
  264. exceptionCaughtDuringExecutionOfPushCommand=Exception caught during execution of push command
  265. exceptionCaughtDuringExecutionOfResetCommand=Exception caught during execution of reset command. {0}
  266. exceptionCaughtDuringExecutionOfRevertCommand=Exception caught during execution of revert command. {0}
  267. exceptionCaughtDuringExecutionOfRmCommand=Exception caught during execution of rm command
  268. exceptionCaughtDuringExecutionOfTagCommand=Exception caught during execution of tag command
  269. exceptionCaughtDuringExcecutionOfCommand=Exception caught during execution of command ''{0}'' in ''{1}'', return code ''{2}'', error message ''{3}''
  270. exceptionHookExecutionInterrupted=Execution of "{0}" hook interrupted.
  271. exceptionOccurredDuringAddingOfOptionToALogCommand=Exception occurred during adding of {0} as option to a Log command
  272. exceptionOccurredDuringReadingOfGIT_DIR=Exception occurred during reading of $GIT_DIR/{0}. {1}
  273. exceptionWhileReadingPack=ERROR: Exception caught while accessing pack file {0}, the pack file might be corrupt
  274. expectedACKNAKFoundEOF=Expected ACK/NAK, found EOF
  275. expectedACKNAKGot=Expected ACK/NAK, got: {0}
  276. expectedBooleanStringValue=Expected boolean string value
  277. expectedCharacterEncodingGuesses=Expected {0} character encoding guesses
  278. expectedEOFReceived=expected EOF; received ''{0}'' instead
  279. expectedGot=expected ''{0}'', got ''{1}''
  280. expectedLessThanGot=expected less than ''{0}'', got ''{1}''
  281. expectedPktLineWithService=expected pkt-line with ''# service=-'', got ''{0}''
  282. expectedReceivedContentType=expected Content-Type {0}; received Content-Type {1}
  283. expectedReportForRefNotReceived={0}: expected report for ref {1} not received
  284. failedToDetermineFilterDefinition=An exception occured while determining filter definitions
  285. failedUpdatingRefs=failed updating refs
  286. failureDueToOneOfTheFollowing=Failure due to one of the following:
  287. failureUpdatingFETCH_HEAD=Failure updating FETCH_HEAD: {0}
  288. failureUpdatingTrackingRef=Failure updating tracking ref {0}: {1}
  289. fileCannotBeDeleted=File cannot be deleted: {0}
  290. fileIsTooBigForThisConvenienceMethod=File is too big for this convenience method ({0} bytes).
  291. fileIsTooLarge=File is too large: {0}
  292. fileModeNotSetForPath=FileMode not set for path {0}
  293. filterExecutionFailed=Execution of filter command ''{0}'' on file ''{1}'' failed
  294. filterExecutionFailedRc=Execution of filter command ''{0}'' on file ''{1}'' failed with return code ''{2}'', message on stderr: ''{3}''
  295. findingGarbage=Finding garbage
  296. flagIsDisposed={0} is disposed.
  297. flagNotFromThis={0} not from this.
  298. flagsAlreadyCreated={0} flags already created.
  299. funnyRefname=funny refname
  300. gcFailed=Garbage collection failed.
  301. gitmodulesNotFound=.gitmodules not found in tree.
  302. headRequiredToStash=HEAD required to stash local changes
  303. hoursAgo={0} hours ago
  304. hugeIndexesAreNotSupportedByJgitYet=Huge indexes are not supported by jgit, yet
  305. hunkBelongsToAnotherFile=Hunk belongs to another file
  306. hunkDisconnectedFromFile=Hunk disconnected from file
  307. hunkHeaderDoesNotMatchBodyLineCountOf=Hunk header {0} does not match body line count of {1}
  308. illegalArgumentNotA=Not {0}
  309. illegalCombinationOfArguments=The combination of arguments {0} and {1} is not allowed
  310. illegalHookName=Illegal hook name {0}
  311. illegalPackingPhase=Illegal packing phase {0}
  312. illegalStateExists=exists {0}
  313. improperlyPaddedBase64Input=Improperly padded Base64 input.
  314. incorrectHashFor=Incorrect hash for {0}; computed {1} as a {2} from {3} bytes.
  315. incorrectOBJECT_ID_LENGTH=Incorrect OBJECT_ID_LENGTH.
  316. indexFileCorruptedNegativeBucketCount=Invalid negative bucket count read from pack v2 index file: {0}
  317. indexFileIsInUse=Index file is in use
  318. indexFileIsTooLargeForJgit=Index file is too large for jgit
  319. indexSignatureIsInvalid=Index signature is invalid: {0}
  320. indexWriteException=Modified index could not be written
  321. initFailedBareRepoDifferentDirs=When initializing a bare repo with directory {0} and separate git-dir {1} specified both folders must point to the same location
  322. initFailedDirIsNoDirectory=Cannot set directory to ''{0}'' which is not a directory
  323. initFailedGitDirIsNoDirectory=Cannot set git-dir to ''{0}'' which is not a directory
  324. initFailedNonBareRepoSameDirs=When initializing a non-bare repo with directory {0} and separate git-dir {1} specified both folders should not point to the same location
  325. inMemoryBufferLimitExceeded=In-memory buffer limit exceeded
  326. inputDidntMatchLength=Input did not match supplied length. {0} bytes are missing.
  327. inputStreamMustSupportMark=InputStream must support mark()
  328. integerValueOutOfRange=Integer value {0}.{1} out of range
  329. internalRevisionError=internal revision error
  330. internalServerError=internal server error
  331. interruptedWriting=Interrupted writing {0}
  332. inTheFuture=in the future
  333. invalidAdvertisementOf=invalid advertisement of {0}
  334. invalidAncestryLength=Invalid ancestry length
  335. invalidBooleanValue=Invalid boolean value: {0}.{1}={2}
  336. invalidChannel=Invalid channel {0}
  337. invalidCharacterInBase64Data=Invalid character in Base64 data.
  338. invalidCommitParentNumber=Invalid commit parent number
  339. invalidDepth=Invalid depth: {0}
  340. invalidEncryption=Invalid encryption
  341. invalidExpandWildcard=ExpandFromSource on a refspec that can have mismatched wildcards does not make sense.
  342. invalidGitdirRef = Invalid .git reference in file ''{0}''
  343. invalidGitType=invalid git type: {0}
  344. invalidId=Invalid id: {0}
  345. invalidId0=Invalid id
  346. invalidIdLength=Invalid id length {0}; should be {1}
  347. invalidIgnoreParamSubmodule=Found invalid ignore param for submodule {0}.
  348. invalidIgnoreRule=Exception caught while parsing ignore rule ''{0}''.
  349. invalidIntegerValue=Invalid integer value: {0}.{1}={2}
  350. invalidKey=Invalid key: {0}
  351. invalidLineInConfigFile=Invalid line in config file
  352. invalidModeFor=Invalid mode {0} for {1} {2} in {3}.
  353. invalidModeForPath=Invalid mode {0} for path {1}
  354. invalidObject=Invalid {0} {1}: {2}
  355. invalidOldIdSent=invalid old id sent
  356. invalidPacketLineHeader=Invalid packet line header: {0}
  357. invalidPath=Invalid path: {0}
  358. invalidPathContainsSeparator=Invalid path (contains separator ''{0}''): {1}
  359. invalidPathPeriodAtEndWindows=Invalid path (period at end is ignored by Windows): {0}
  360. invalidPathSpaceAtEndWindows=Invalid path (space at end is ignored by Windows): {0}
  361. invalidPathReservedOnWindows=Invalid path (''{0}'' is reserved on Windows): {1}
  362. invalidReflogRevision=Invalid reflog revision: {0}
  363. invalidRefName=Invalid ref name: {0}
  364. invalidRemote=Invalid remote: {0}
  365. invalidRepositoryStateNoHead=Invalid repository --- cannot read HEAD
  366. invalidShallowObject=invalid shallow object {0}, expected commit
  367. invalidStageForPath=Invalid stage {0} for path {1}
  368. invalidTagOption=Invalid tag option: {0}
  369. invalidTimeout=Invalid timeout: {0}
  370. invalidTimeUnitValue2=Invalid time unit value: {0}.{1}={2}
  371. invalidTimeUnitValue3=Invalid time unit value: {0}.{1}.{2}={3}
  372. invalidTreeZeroLengthName=Cannot append a tree entry with zero-length name
  373. invalidURL=Invalid URL {0}
  374. invalidWildcards=Invalid wildcards {0}
  375. invalidRefSpec=Invalid refspec {0}
  376. invalidWindowSize=Invalid window size
  377. isAStaticFlagAndHasNorevWalkInstance={0} is a static flag and has no RevWalk instance
  378. JRELacksMD5Implementation=JRE lacks MD5 implementation
  379. kNotInRange=k {0} not in {1} - {2}
  380. largeObjectExceedsByteArray=Object {0} exceeds 2 GiB byte array limit
  381. largeObjectExceedsLimit=Object {0} exceeds {1} limit, actual size is {2}
  382. largeObjectException={0} exceeds size limit
  383. largeObjectOutOfMemory=Out of memory loading {0}
  384. lengthExceedsMaximumArraySize=Length exceeds maximum array size
  385. listingAlternates=Listing alternates
  386. listingPacks=Listing packs
  387. localObjectsIncomplete=Local objects incomplete.
  388. localRefIsMissingObjects=Local ref {0} is missing object(s).
  389. localRepository=local repository
  390. lockCountMustBeGreaterOrEqual1=lockCount must be >= 1
  391. lockError=lock error: {0}
  392. lockOnNotClosed=Lock on {0} not closed.
  393. lockOnNotHeld=Lock on {0} not held.
  394. malformedpersonIdentString=Malformed PersonIdent string (no < was found): {0}
  395. maxCountMustBeNonNegative=max count must be >= 0
  396. mergeConflictOnNonNoteEntries=Merge conflict on non-note entries: base = {0}, ours = {1}, theirs = {2}
  397. mergeConflictOnNotes=Merge conflict on note {0}. base = {1}, ours = {2}, theirs = {2}
  398. mergeStrategyAlreadyExistsAsDefault=Merge strategy "{0}" already exists as a default strategy
  399. mergeStrategyDoesNotSupportHeads=merge strategy {0} does not support {1} heads to be merged into HEAD
  400. mergeUsingStrategyResultedInDescription=Merge of revisions {0} with base {1} using strategy {2} resulted in: {3}. {4}
  401. mergeRecursiveConflictsWhenMergingCommonAncestors=Multiple common ancestors were found and merging them resulted in a conflict: {0}, {1}
  402. mergeRecursiveReturnedNoCommit=Merge returned no commit:\n Depth {0}\n Head one {1}\n Head two {2}
  403. mergeRecursiveTooManyMergeBasesFor = "More than {0} merge bases for:\n a {1}\n b {2} found:\n count {3}"
  404. messageAndTaggerNotAllowedInUnannotatedTags = Unannotated tags cannot have a message or tagger
  405. minutesAgo={0} minutes ago
  406. missingAccesskey=Missing accesskey.
  407. missingConfigurationForKey=No value for key {0} found in configuration
  408. missingDeltaBase=delta base
  409. missingForwardImageInGITBinaryPatch=Missing forward-image in GIT binary patch
  410. missingObject=Missing {0} {1}
  411. missingPrerequisiteCommits=missing prerequisite commits:
  412. missingRequiredParameter=Parameter "{0}" is missing
  413. missingSecretkey=Missing secretkey.
  414. mixedStagesNotAllowed=Mixed stages not allowed
  415. mkDirFailed=Creating directory {0} failed
  416. mkDirsFailed=Creating directories for {0} failed
  417. month=month
  418. months=months
  419. monthsAgo={0} months ago
  420. multipleMergeBasesFor=Multiple merge bases for:\n {0}\n {1} found:\n {2}\n {3}
  421. need2Arguments=Need 2 arguments
  422. needPackOut=need packOut
  423. needsAtLeastOneEntry=Needs at least one entry
  424. needsWorkdir=Needs workdir
  425. newlineInQuotesNotAllowed=Newline in quotes not allowed
  426. noApplyInDelete=No apply in delete
  427. noClosingBracket=No closing {0} found for {1} at index {2}.
  428. noCredentialsProvider=Authentication is required but no CredentialsProvider has been registered
  429. noHEADExistsAndNoExplicitStartingRevisionWasSpecified=No HEAD exists and no explicit starting revision was specified
  430. noHMACsupport=No {0} support: {1}
  431. noMergeBase=No merge base could be determined. Reason={0}. {1}
  432. noMergeHeadSpecified=No merge head specified
  433. noSuchRef=no such ref
  434. notABoolean=Not a boolean: {0}
  435. notABundle=not a bundle
  436. notADIRCFile=Not a DIRC file.
  437. notAGitDirectory=not a git directory
  438. notAPACKFile=Not a PACK file.
  439. notARef=Not a ref: {0}: {1}
  440. notASCIIString=Not ASCII string: {0}
  441. notAuthorized=not authorized
  442. notAValidPack=Not a valid pack {0}
  443. notFound=not found.
  444. nothingToFetch=Nothing to fetch.
  445. nothingToPush=Nothing to push.
  446. notMergedExceptionMessage=Branch was not deleted as it has not been merged yet; use the force option to delete it anyway
  447. noXMLParserAvailable=No XML parser available.
  448. objectAtHasBadZlibStream=Object at {0} in {1} has bad zlib stream
  449. objectAtPathDoesNotHaveId=Object at path "{0}" does not have an id assigned. All object ids must be assigned prior to writing a tree.
  450. objectIsCorrupt=Object {0} is corrupt: {1}
  451. objectIsCorrupt3={0}: object {1}: {2}
  452. objectIsNotA=Object {0} is not a {1}.
  453. objectNotFound=Object {0} not found.
  454. objectNotFoundIn=Object {0} not found in {1}.
  455. obtainingCommitsForCherryPick=Obtaining commits that need to be cherry-picked
  456. offsetWrittenDeltaBaseForObjectNotFoundInAPack=Offset-written delta base for object not found in a pack
  457. onlyAlreadyUpToDateAndFastForwardMergesAreAvailable=only already-up-to-date and fast forward merges are available
  458. onlyOneFetchSupported=Only one fetch supported
  459. onlyOneOperationCallPerConnectionIsSupported=Only one operation call per connection is supported.
  460. openFilesMustBeAtLeast1=Open files must be >= 1
  461. openingConnection=Opening connection
  462. operationCanceled=Operation {0} was canceled
  463. outputHasAlreadyBeenStarted=Output has already been started.
  464. packChecksumMismatch=Pack checksum mismatch detected for pack file {0}
  465. packCorruptedWhileWritingToFilesystem=Pack corrupted while writing to filesystem
  466. packDoesNotMatchIndex=Pack {0} does not match index
  467. packedRefsHandleIsStale=packed-refs handle is stale, {0}. retry
  468. packetSizeMustBeAtLeast=packet size {0} must be >= {1}
  469. packetSizeMustBeAtMost=packet size {0} must be <= {1}
  470. packedRefsCorruptionDetected=packed-refs corruption detected: {0}
  471. packfileCorruptionDetected=Packfile corruption detected: {0}
  472. packFileInvalid=Pack file invalid: {0}
  473. packfileIsTruncated=Packfile {0} is truncated.
  474. packfileIsTruncatedNoParam=Packfile is truncated.
  475. packHandleIsStale=Pack file {0} handle is stale, removing it from pack list
  476. packHasUnresolvedDeltas=pack has unresolved deltas
  477. packInaccessible=Pack file {0} now inaccessible; removing it from pack list
  478. packingCancelledDuringObjectsWriting=Packing cancelled during objects writing
  479. packObjectCountMismatch=Pack object count mismatch: pack {0} index {1}: {2}
  480. packRefs=Pack refs
  481. packSizeNotSetYet=Pack size not yet set since it has not yet been received
  482. packTooLargeForIndexVersion1=Pack too large for index version 1
  483. packWasDeleted=Pack file {0} was deleted, removing it from pack list
  484. packWriterStatistics=Total {0,number,#0} (delta {1,number,#0}), reused {2,number,#0} (delta {3,number,#0})
  485. panicCantRenameIndexFile=Panic: index file {0} must be renamed to replace {1}; until then repository is corrupt
  486. patchApplyException=Cannot apply: {0}
  487. patchFormatException=Format error: {0}
  488. pathIsNotInWorkingDir=Path is not in working dir
  489. pathNotConfigured=Submodule path is not configured
  490. peeledLineBeforeRef=Peeled line before ref.
  491. peerDidNotSupplyACompleteObjectGraph=peer did not supply a complete object graph
  492. personIdentEmailNonNull=E-mail address of PersonIdent must not be null.
  493. personIdentNameNonNull=Name of PersonIdent must not be null.
  494. prefixRemote=remote:
  495. problemWithResolvingPushRefSpecsLocally=Problem with resolving push ref specs locally: {0}
  496. progressMonUploading=Uploading {0}
  497. propertyIsAlreadyNonNull=Property is already non null
  498. pruneLoosePackedObjects=Prune loose objects also found in pack files
  499. pruneLooseUnreferencedObjects=Prune loose, unreferenced objects
  500. pullOnRepoWithoutHEADCurrentlyNotSupported=Pull on repository without HEAD currently not supported
  501. pullTaskName=Pull
  502. pushCancelled=push cancelled
  503. pushCertificateInvalidField=Push certificate has missing or invalid value for {0}
  504. pushCertificateInvalidFieldValue=Push certificate has missing or invalid value for {0}: {1}
  505. pushCertificateInvalidHeader=Push certificate has invalid header format
  506. pushCertificateInvalidSignature=Push certificate has invalid signature format
  507. pushIsNotSupportedForBundleTransport=Push is not supported for bundle transport
  508. pushNotPermitted=push not permitted
  509. pushOptionsNotSupported=Push options not supported; received {0}
  510. rawLogMessageDoesNotParseAsLogEntry=Raw log message does not parse as log entry
  511. readerIsRequired=Reader is required
  512. readingObjectsFromLocalRepositoryFailed=reading objects from local repository failed: {0}
  513. readTimedOut=Read timed out after {0} ms
  514. receivePackObjectTooLarge1=Object too large, rejecting the pack. Max object size limit is {0} bytes.
  515. receivePackObjectTooLarge2=Object too large ({0} bytes), rejecting the pack. Max object size limit is {1} bytes.
  516. receivePackInvalidLimit=Illegal limit parameter value {0}
  517. receivePackTooLarge=Pack exceeds the limit of {0} bytes, rejecting the pack
  518. receivingObjects=Receiving objects
  519. refAlreadyExists=already exists
  520. refAlreadyExists1=Ref {0} already exists
  521. reflogEntryNotFound=Entry {0} not found in reflog for ''{1}''
  522. refNotResolved=Ref {0} can not be resolved
  523. refUpdateReturnCodeWas=RefUpdate return code was: {0}
  524. remoteConfigHasNoURIAssociated=Remote config "{0}" has no URIs associated
  525. remoteDoesNotHaveSpec=Remote does not have {0} available for fetch.
  526. remoteDoesNotSupportSmartHTTPPush=remote does not support smart HTTP push
  527. remoteHungUpUnexpectedly=remote hung up unexpectedly
  528. remoteNameCantBeNull=Remote name can't be null.
  529. renameBranchFailedBecauseTag=Can not rename as Ref {0} is a tag
  530. renameBranchFailedUnknownReason=Rename failed with unknown reason
  531. renameBranchUnexpectedResult=Unexpected rename result {0}
  532. renameFileFailed=Could not rename file {0} to {1}
  533. renamesAlreadyFound=Renames have already been found.
  534. renamesBreakingModifies=Breaking apart modified file pairs
  535. renamesFindingByContent=Finding renames by content similarity
  536. renamesFindingExact=Finding exact renames
  537. renamesRejoiningModifies=Rejoining modified file pairs
  538. repositoryAlreadyExists=Repository already exists: {0}
  539. repositoryConfigFileInvalid=Repository config file {0} invalid {1}
  540. repositoryNotFound=repository not found: {0}
  541. repositoryState_applyMailbox=Apply mailbox
  542. repositoryState_bare=Bare
  543. repositoryState_bisecting=Bisecting
  544. repositoryState_conflicts=Conflicts
  545. repositoryState_merged=Merged
  546. repositoryState_normal=Normal
  547. repositoryState_rebase=Rebase
  548. repositoryState_rebaseInteractive=Rebase interactive
  549. repositoryState_rebaseOrApplyMailbox=Rebase/Apply mailbox
  550. repositoryState_rebaseWithMerge=Rebase w/merge
  551. requiredHashFunctionNotAvailable=Required hash function {0} not available.
  552. resettingHead=Resetting head to {0}
  553. resolvingDeltas=Resolving deltas
  554. resultLengthIncorrect=result length incorrect
  555. rewinding=Rewinding to commit {0}
  556. s3ActionDeletion=Deletion
  557. s3ActionReading=Reading
  558. s3ActionWriting=Writing
  559. searchForReuse=Finding sources
  560. searchForSizes=Getting sizes
  561. secondsAgo={0} seconds ago
  562. selectingCommits=Selecting commits
  563. sequenceTooLargeForDiffAlgorithm=Sequence too large for difference algorithm.
  564. serviceNotEnabledNoName=Service not enabled
  565. serviceNotPermitted={0} not permitted
  566. shallowCommitsAlreadyInitialized=Shallow commits have already been initialized
  567. shallowPacksRequireDepthWalk=Shallow packs require a DepthWalk
  568. shortCompressedStreamAt=Short compressed stream at {0}
  569. shortReadOfBlock=Short read of block.
  570. shortReadOfOptionalDIRCExtensionExpectedAnotherBytes=Short read of optional DIRC extension {0}; expected another {1} bytes within the section.
  571. shortSkipOfBlock=Short skip of block.
  572. signingNotSupportedOnTag=Signing isn't supported on tag operations yet.
  573. similarityScoreMustBeWithinBounds=Similarity score must be between 0 and 100.
  574. sizeExceeds2GB=Path {0} size {1} exceeds 2 GiB limit.
  575. skipMustBeNonNegative=skip must be >= 0
  576. smartHTTPPushDisabled=smart HTTP push disabled
  577. sourceDestinationMustMatch=Source/Destination must match.
  578. sourceIsNotAWildcard=Source is not a wildcard.
  579. sourceRefDoesntResolveToAnyObject=Source ref {0} doesn''t resolve to any object.
  580. sourceRefNotSpecifiedForRefspec=Source ref not specified for refspec: {0}
  581. squashCommitNotUpdatingHEAD=Squash commit -- not updating HEAD
  582. staleRevFlagsOn=Stale RevFlags on {0}
  583. startingReadStageWithoutWrittenRequestDataPendingIsNotSupported=Starting read stage without written request data pending is not supported
  584. stashApplyConflict=Applying stashed changes resulted in a conflict
  585. stashApplyConflictInIndex=Applying stashed index changes resulted in a conflict. Dropped index changes.
  586. stashApplyFailed=Applying stashed changes did not successfully complete
  587. stashApplyOnUnsafeRepository=Cannot apply stashed commit on a repository with state: {0}
  588. stashApplyWithoutHead=Cannot apply stashed commit in an empty repository or onto an unborn branch
  589. stashCommitIncorrectNumberOfParents=Stashed commit ''{0}'' does have {1} parent commits instead of 2 or 3.
  590. stashDropDeleteRefFailed=Deleting stash reference failed with result: {0}
  591. stashDropFailed=Dropping stashed commit failed
  592. stashDropMissingReflog=Stash reflog does not contain entry ''{0}''
  593. stashFailed=Stashing local changes did not successfully complete
  594. stashResolveFailed=Reference ''{0}'' does not resolve to stashed commit
  595. statelessRPCRequiresOptionToBeEnabled=stateless RPC requires {0} to be enabled
  596. storePushCertMultipleRefs=Store push certificate for {0} refs
  597. storePushCertOneRef=Store push certificate for {0}
  598. storePushCertReflog=Store push certificate
  599. submoduleExists=Submodule ''{0}'' already exists in the index
  600. submoduleParentRemoteUrlInvalid=Cannot remove segment from remote url ''{0}''
  601. submodulesNotSupported=Submodules are not supported
  602. supportOnlyPackIndexVersion2=Only support index version 2
  603. symlinkCannotBeWrittenAsTheLinkTarget=Symlink "{0}" cannot be written as the link target cannot be read from within Java.
  604. systemConfigFileInvalid=System wide config file {0} is invalid {1}
  605. tagAlreadyExists=tag ''{0}'' already exists
  606. tagNameInvalid=tag name {0} is invalid
  607. tagOnRepoWithoutHEADCurrentlyNotSupported=Tag on repository without HEAD currently not supported
  608. theFactoryMustNotBeNull=The factory must not be null
  609. timeIsUncertain=Time is uncertain
  610. timerAlreadyTerminated=Timer already terminated
  611. tooManyIncludeRecursions=Too many recursions; circular includes in config file(s)?
  612. topologicalSortRequired=Topological sort required.
  613. transactionAborted=transaction aborted
  614. transportExceptionBadRef=Empty ref: {0}: {1}
  615. transportExceptionEmptyRef=Empty ref: {0}
  616. transportExceptionInvalid=Invalid {0} {1}:{2}
  617. transportExceptionMissingAssumed=Missing assumed {0}
  618. transportExceptionReadRef=read {0}
  619. transportNeedsRepository=Transport needs repository
  620. transportProvidedRefWithNoObjectId=Transport provided ref {0} with no object id
  621. transportProtoAmazonS3=Amazon S3
  622. transportProtoBundleFile=Git Bundle File
  623. transportProtoFTP=FTP
  624. transportProtoGitAnon=Anonymous Git
  625. transportProtoHTTP=HTTP
  626. transportProtoLocal=Local Git Repository
  627. transportProtoSFTP=SFTP
  628. transportProtoSSH=SSH
  629. transportProtoTest=Test
  630. transportSSHRetryInterrupt=Interrupted while waiting for retry
  631. treeEntryAlreadyExists=Tree entry "{0}" already exists.
  632. treeFilterMarkerTooManyFilters=Too many markTreeFilters passed, maximum number is {0} (passed {1})
  633. treeIteratorDoesNotSupportRemove=TreeIterator does not support remove()
  634. treeWalkMustHaveExactlyTwoTrees=TreeWalk should have exactly two trees.
  635. truncatedHunkLinesMissingForAncestor=Truncated hunk, at least {0} lines missing for ancestor {1}
  636. truncatedHunkNewLinesMissing=Truncated hunk, at least {0} new lines is missing
  637. truncatedHunkOldLinesMissing=Truncated hunk, at least {0} old lines is missing
  638. tSizeMustBeGreaterOrEqual1=tSize must be >= 1
  639. unableToCheckConnectivity=Unable to check connectivity.
  640. unableToCreateNewObject=Unable to create new object: {0}
  641. unableToStore=Unable to store {0}.
  642. unableToWrite=Unable to write {0}
  643. unauthorized=Unauthorized
  644. unencodeableFile=Unencodable file: {0}
  645. unexpectedCompareResult=Unexpected metadata comparison result: {0}
  646. unexpectedEndOfConfigFile=Unexpected end of config file
  647. unexpectedEndOfInput=Unexpected end of input
  648. unexpectedHunkTrailer=Unexpected hunk trailer
  649. unexpectedOddResult=odd: {0} + {1} - {2}
  650. unexpectedRefReport={0}: unexpected ref report: {1}
  651. unexpectedReportLine=unexpected report line: {0}
  652. unexpectedReportLine2={0} unexpected report line: {1}
  653. unknownOrUnsupportedCommand=Unknown or unsupported command "{0}", only "{1}" is allowed.
  654. unknownDIRCVersion=Unknown DIRC version {0}
  655. unknownHost=unknown host
  656. unknownIndexVersionOrCorruptIndex=Unknown index version (or corrupt index): {0}
  657. unknownObject=unknown object
  658. unknownObjectType=Unknown object type {0}.
  659. unknownObjectType2=unknown
  660. unknownRepositoryFormat=Unknown repository format
  661. unknownRepositoryFormat2=Unknown repository format "{0}"; expected "0".
  662. unknownZlibError=Unknown zlib error.
  663. unmergedPath=Unmerged path: {0}
  664. unmergedPaths=Repository contains unmerged paths
  665. unpackException=Exception while parsing pack stream
  666. unreadablePackIndex=Unreadable pack index: {0}
  667. unrecognizedRef=Unrecognized ref: {0}
  668. unsetMark=Mark not set
  669. unsupportedAlternates=Alternates not supported
  670. unsupportedArchiveFormat=Unknown archive format ''{0}''
  671. unsupportedCommand0=unsupported command 0
  672. unsupportedEncryptionAlgorithm=Unsupported encryption algorithm: {0}
  673. unsupportedEncryptionVersion=Unsupported encryption version: {0}
  674. unsupportedGC=Unsupported garbage collector for repository type: {0}
  675. unsupportedMark=Mark not supported
  676. unsupportedOperationNotAddAtEnd=Not add-at-end: {0}
  677. unsupportedPackIndexVersion=Unsupported pack index version {0}
  678. unsupportedPackVersion=Unsupported pack version {0}.
  679. unsupportedRepositoryDescription=Repository description not supported
  680. updatingHeadFailed=Updating HEAD failed
  681. updatingReferences=Updating references
  682. updatingRefFailed=Updating the ref {0} to {1} failed. ReturnCode from RefUpdate.update() was {2}
  683. upstreamBranchName=branch ''{0}'' of {1}
  684. uriNotConfigured=Submodule URI not configured
  685. uriNotFound={0} not found
  686. URINotSupported=URI not supported: {0}
  687. URLNotFound={0} not found
  688. userConfigFileInvalid=User config file {0} invalid {1}
  689. walkFailure=Walk failure.
  690. wantNotValid=want {0} not valid
  691. weeksAgo={0} weeks ago
  692. windowSizeMustBeLesserThanLimit=Window size must be < limit
  693. windowSizeMustBePowerOf2=Window size must be power of 2
  694. writerAlreadyInitialized=Writer already initialized
  695. writeTimedOut=Write timed out after {0} ms
  696. writingNotPermitted=Writing not permitted
  697. writingNotSupported=Writing {0} not supported.
  698. writingObjects=Writing objects
  699. wrongDecompressedLength=wrong decompressed length
  700. wrongRepositoryState=Wrong Repository State: {0}
  701. year=year
  702. years=years
  703. years0MonthsAgo={0} {1} ago
  704. yearsAgo={0} years ago
  705. yearsMonthsAgo={0} {1}, {2} {3} ago