{"checks":{"bugzilla_create_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Create <a href=\"https:\/\/bugs.eclipse.org\/bugs\/enter_bug.cgi?product=JGit\">URL<\/a> could be successfully fetched."],"value":"https:\/\/bugs.eclipse.org\/bugs\/enter_bug.cgi?product=JGit"},"bugzilla_query_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Query <a href=\"https:\/\/bugs.eclipse.org\/bugs\/buglist.cgi?product=JGit\">URL<\/a> could be successfully fetched."],"value":"https:\/\/bugs.eclipse.org\/bugs\/buglist.cgi?product=JGit"},"build_url":{"desc":"Sends a get request to the given CI URL and looks at the headers in the response (200, 404..). Also checks if the URL is really a Hudson instance (through a call to its API).","results":["OK. Fetched CI URL.","OK. CI URL is a Hudson instance. Title is [built-in]"],"value":"https:\/\/ci.eclipse.org\/jgit"},"dev_list":{"desc":"Checks if the Dev ML URL can be fetched using a simple get query.","results":["OK: Dev ML <a href=\"https:\/\/dev.eclipse.org\/mailman\/listinfo\/jgit-dev\">URL<\/a> could be successfully fetched."],"value":"https:\/\/dev.eclipse.org\/mailman\/listinfo\/jgit-dev"},"documentation_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Documentation <a href=\"https:\/\/www.eclipse.org\/jgit\/documentation\/\">URL<\/a> could be successfully fetched."],"value":"https:\/\/www.eclipse.org\/jgit\/documentation\/"},"download_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Download <a href=\"https:\/\/www.eclipse.org\/jgit\/download\/\">URL<\/a> could be successfully fetched."],"value":"https:\/\/www.eclipse.org\/jgit\/download\/"},"forums":{"desc":"Checks if the Forums URL can be fetched using a simple get query.","results":["OK. Forum [JGit and EGit forum] correctly defined.","OK: Forum [JGit and EGit forum] <a href=\"https:\/\/eclipse.org\/forums\/eclipse.egit\">URL<\/a> could be successfully fetched."],"value":"https:\/\/eclipse.org\/forums\/eclipse.egit"},"gettingstarted_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["Failed: no URL defined for gettingstarted_url."]},"mailing_lists":{"desc":"Checks if the Mailing lists URL can be fetched using a simple get query.","results":["OK. [jgit-build] ML correctly defined with email.","OK: [jgit-build] ML <a href=\"https:\/\/dev.eclipse.org\/mailman\/listinfo\/jgit-build\">URL<\/a> could be successfully fetched."],"value":"https:\/\/dev.eclipse.org\/mailman\/listinfo\/jgit-build"},"plan_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["Failed: no URL defined for plan."]},"proposal_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["Failed: no URL defined for proposal."]},"releases":{"desc":"Checks if the releases have been correctly filled.","results":["Failed. Review for [6.1.0] type [2] is [none] on [2022-03-16 00:00:00].","Failed. Review for [6.0.0] type [1] is [none] on [2021-12-08 00:00:00].","Failed. Review for [5.13.0] type [2] is [none] on [2021-09-15 00:00:00].","OK. Review for [5.12.0] is 'success'.","Failed. Review for [5.11.0] type [2] is [none] on [2021-03-17 00:00:00].","Failed. Review for [5.10.0] type [2] is [none] on [2020-12-16 00:00:00].","Failed. Review for [5.9.0] type [2] is [none] on [2020-09-16 00:00:00].","OK. Review for [5.8.0] is 'success'.","Failed. Review for [5.7.0] type [2] is [pending] on [2020-03-18 00:00:00].","OK. Review for [5.6.0] is 'success'.","OK. Review for [5.5.0] is 'success'.","OK. Review for [5.4.0] is 'success'.","OK. Review for [5.3.0] is 'success'.","OK. Review for [5.2.0] is 'success'.","OK. Review for [5.1.0] is 'success'.","OK. Review for [5.0.0] is 'success'.","OK. Review for [4.11.0] is 'success'.","OK. Review for [4.10.0] is 'success'.","OK. Review for [4.9.0] is 'success'.","OK. Review for [4.8.0] is 'success'.","OK. Review for [4.7.0] is 'success'.","OK. Review for [4.6] is 'success'.","OK. Review for [4.5] is 'success'.","OK. Review for [4.4] is 'success'.","OK. Review for [4.3] is 'success'.","OK. Review for [4.2] is 'success'.","OK. Review for [4.1.0] is 'success'.","OK. Review for [4.0.0] is 'success'.","OK. Review for [3.7.0] is 'success'.","OK. Review for [3.6.0] is 'success'.","OK. Review for [3.5.0] is 'success'.","OK. Review for [3.4.0] is 'success'.","OK. Review for [3.3.0] is 'success'.","OK. Review for [3.2.0] is 'success'.","OK. Review for [3.1.0] is 'success'.","Failed. Review for [3.0.2] type [1] is [none] on [2013-09-27 00:00:00].","OK. Review for [3.0.0] is 'success'.","Failed. Review for [2.3.1] type [1] is [none] on [2013-03-01 00:00:00].","OK. Review for [2.3.0] is 'success'.","OK. Review for [2.2.0] is 'success'.","OK. Review for [2.1.0] is 'success'.","OK. Review for [2.0.0] is 'success'.","OK. Review for [1.3.0] is 'success'.","OK. Review for [1.2.0] is 'success'.","OK. Review for [1.1.0] is 'success'.","OK. Review for [1.0.0] is 'success'.","Failed. Review for [0.12.1] type [1] is [none] on [2011-05-03 00:00:00].","Failed. Review for [0.11.3] type [1] is [none] on [2011-02-21 00:00:00].","Failed. Review for [0.10.1] type [1] is [none] on [2010-12-17 00:00:00].","Failed. Review for [0.9.3] type [1] is [none] on [2010-09-17 00:00:00].","Failed. Review for [0.8.4] type [1] is [none] on [2010-06-14 00:00:00].","Failed. Review for [0.7.1] type [1] is [none] on [2010-03-22 00:00:00].","Failed. Review for [0.7.0] type [1] is [none] on [2010-03-19 00:00:00]."]},"source_repo":{"desc":"Checks if the Source repositories are filled and can be fetched using a simple get query.","results":["OK. Source repo [jgit\/jgit] type [git] path [\/gitroot\/jgit\/jgit.git].","OK: Source repo [jgit\/jgit] <a href=\"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/jgit\/jgit\">URL<\/a> could be successfully fetched."],"value":"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/jgit\/jgit"},"title":{"desc":"Checks if a name is defined for the project: !~ m!^\\s*$!","results":["OK"],"value":"Eclipse JGit™: Java implementation of Git"},"update_sites":{"desc":"Checks if the update sites can be fetched using a simple get query.","results":["OK. Update site [jgit and egit update site - releases] has title.","OK: Update site [jgit and egit update site - releases] <a href=\"https:\/\/download.eclipse.org\/egit\/updates\">URL<\/a> could be successfully fetched.","OK. Update site [jgit and egit update site - master branch] has title.","OK: Update site [jgit and egit update site - master branch] <a href=\"https:\/\/download.eclipse.org\/egit\/updates-nightly\">URL<\/a> could be successfully fetched."],"value":"https:\/\/download.eclipse.org\/egit\/updates-nightly"},"website_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Website <a href=\"https:\/\/www.eclipse.org\/jgit\/\">URL<\/a> could be successfully fetched."],"value":"https:\/\/www.eclipse.org\/jgit\/"},"wiki_url":{"desc":"Sends a get request to the project wiki URL and looks at the headers in the response (200, 404..).","results":["OK: Wiki <a href=\"https:\/\/wiki.eclipse.org\/JGit\">URL<\/a> could be successfully fetched."],"value":"https:\/\/wiki.eclipse.org\/JGit"}},"id_pmi":"technology.jgit","last_update":1650761191,"name":"Eclipse JGit™: Java implementation of Git","pmi":{"bugzilla":[{"component":"","create_url":"https:\/\/bugs.eclipse.org\/bugs\/enter_bug.cgi?product=JGit","product":"JGit","query_url":"https:\/\/bugs.eclipse.org\/bugs\/buglist.cgi?product=JGit"}],"build_description":[],"build_doc":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/EGit\/Contributor_Guide#JGit_2"}],"build_technologies":[{"tid":"962"},{"tid":"7"},{"tid":"6"}],"build_url":[{"attributes":[],"title":"JGit builds","url":"https:\/\/ci.eclipse.org\/jgit"},{"attributes":[],"title":"JGit builds (master branch)","url":"https:\/\/ci.eclipse.org\/jgit\/job\/jgit\/"},{"attributes":[],"title":"JGit build (latest maintenance branch)","url":"https:\/\/ci.eclipse.org\/jgit\/job\/stable\/job\/jgit-stable-pipeline\/"},{"attributes":[],"title":"JGit verification build (changes in review)","url":"https:\/\/ci.eclipse.org\/jgit\/job\/stable\/job\/jgit.gerrit-pipeline\/"}],"contrib_message":[{"format":"full_html","safe_value":"<p>The EGit contributor guide helps you to create your first contribution. :)<\/p>\n","value":"<p>The EGit contributor guide helps you to create your first contribution. :)<\/p>\r\n"}],"contributors":[],"description":[{"format":"filtered_html","safe_summary":"","safe_value":"<p>Eclipse JGit™ is a pure Java implementation of the Git version control system. Git is a distributed SCM, which means every developer has a full copy of all history of every revision of the code, making queries against the history very fast and versatile.<\/p>","summary":"","value":"<p>Eclipse JGit&trade; is a pure Java implementation of the Git version control system. Git is a distributed SCM, which means every developer has a full copy of all history of every revision of the code, making queries against the history very fast and versatile.<\/p>\r\n"}],"dev_list":{"email":"cSmSDFGV27dWafJS@eTt28f16hVTiHKpb","name":"jgit-dev","url":"https:\/\/dev.eclipse.org\/mailman\/listinfo\/jgit-dev"},"documentation":[],"documentation_url":[{"attributes":[],"title":null,"url":"https:\/\/www.eclipse.org\/jgit\/documentation\/"}],"download_url":[{"attributes":[],"title":null,"url":"https:\/\/www.eclipse.org\/jgit\/download\/"}],"downloads":[{"attributes":[],"title":"Eclipse maven repository","url":"https:\/\/repo.eclipse.org\/content\/groups\/jgit\/"},{"attributes":[],"title":"JGit on maven central","url":"https:\/\/search.maven.org\/search?q=g:org.eclipse.jgit"}],"downloads_message":[],"forums":[{"description":"","name":"JGit and EGit forum","url":"https:\/\/eclipse.org\/forums\/eclipse.egit"}],"gettingstarted_url":[{}],"github_repos":[],"gitlab_repos":[],"id":[{"format":null,"safe_value":"technology.jgit","value":"technology.jgit"}],"ip_due_diligence_type":[{"tid":"289"}],"licenses":[{"name":"Eclipse Distribution License 1.0 (BSD)","url":"http:\/\/www.eclipse.org\/org\/documents\/edl-v10.php"}],"logo":[{"alt":"","fid":"16","filemime":"image\/png","filename":"jgit.png","filesize":"13638","height":"142","rdf_mapping":[],"status":"1","timestamp":"1364013890","title":"","uid":"1974","uri":"public:\/\/jgit_0.png","width":"143"}],"mailing_lists":[{"email":"aJ9N6uEeVt+ng9nI@eTt28f16hVTiHKpb","name":"jgit-build","url":"https:\/\/dev.eclipse.org\/mailman\/listinfo\/jgit-build"}],"marketplace":[],"other_links":[],"parent_project":[{"id":"technology"}],"patent_license":[],"plan_url":[{}],"pmi_url":"https:\/\/projects.eclipse.org\/json\/project\/technology.jgit","proposal_url":[{}],"related":[{"id":"technology.egit"}],"releases":[{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2022-03-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li><a href=\"https:\/\/eclip.se\/353405\">353405<\/a> [push] support the \"matching\" RefSpecs \":\" and \"+:\"<\/li>\n<li><a href=\"https:\/\/eclip.se\/565251\">565251<\/a> IndexDiff: use tree filter also for SubmoduleWalk<\/li>\n<li>Describe: add support for core.abbrev config option<\/li>\n<li>Add a typed config getter for integers confined to a range<\/li>\n<li>PersonIdent: Add ctors that accept Instant in addition to Date<\/li>\n<li>Cap describe abbrev option, minimum is 4, maximum is length of a full ObjectId<\/li>\n<li>DescribeCommand: Add support for --abbrev=0<\/li>\n<li><a href=\"https:\/\/eclip.se\/537883\">537883<\/a> DescribeCommand: Support configuring the hash abbreviation<\/li>\n<li><a href=\"https:\/\/eclip.se\/578676\">578676<\/a> PushCommand: determine remote from git config if not given<\/li>\n<li><a href=\"https:\/\/eclip.se\/351314\">351314<\/a> PushCommand: consider push.default when no RefSpecs are given<\/li>\n<li><a href=\"https:\/\/eclip.se\/351314\">351314<\/a> Support for git config push.default<\/li>\n<li><a href=\"https:\/\/eclip.se\/578020\">578020<\/a> Support for \"lfs.url\" from \".lfsconfig\"<\/li>\n<li><a href=\"https:\/\/eclip.se\/578621\">578621<\/a> Support LFS Server URL without .git suffix<\/li>\n<li><a href=\"https:\/\/eclip.se\/440211\">440211<\/a> [rebase] Enable users to have a Change-ID be generated when squashing or rewording commits.<\/li>\n<li>RepoCommand: Add API to set extra files in the destination repository<\/li>\n<li><a href=\"https:\/\/eclip.se\/578173\">578173<\/a> RebaseCommand: better commit message rewording. Respect git config commit.cleanup for rewording.<\/li>\n<li><a href=\"https:\/\/eclip.se\/553065\">553065<\/a> CommitCommand: implement git commit --cleanup.<\/li>\n<li><a href=\"https:\/\/eclip.se\/553065\">553065<\/a> Provide git config commit.cleanup<\/li>\n<li>sshd: support the ConnectTimeout ssh config<\/li>\n<li>sshd: Skip unknown keys from the SSH agent<\/li>\n<li><a href=\"https:\/\/eclip.se\/577052\">577052<\/a> sshd: support the AddKeysToAgent ssh config<\/li>\n<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> sshd: handle \"IdentityAgent SSH_AUTH_SOCK\" in ssh config<\/li>\n<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> sshd: Connector for the Win32-OpenSSH SSH agent<\/li>\n<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> sshd: handle IdentitiesOnly with an SSH agent<\/li>\n<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> shd: support IdentityAgent config<\/li>\n<li>DFS block cache: report index load and evict stats<\/li>\n<li>Use slf4j-simple instead of log4j for logging<\/li>\n<li><a href=\"https:\/\/eclip.se\/356832\">356832<\/a> Add config reader for user-defined difftools<\/li>\n<li><a href=\"https:\/\/eclip.se\/356832\">356832<\/a> Add command line support for \"git difftool\"<\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li>Transport: load all refs only if push refspecs have wildcards<\/li>\n<li><a href=\"https:\/\/eclip.se\/577937\">577937<\/a> UploadPack v2 protocol: Stop negotiation for orphan refs<\/li>\n<li>PackBitmapIndexV1: support parallel loading of reverse index<\/li>\n<li>RefDirectory.scanRef: Re-use file existence check done in snapshot creation<\/li>\n<li>FileSnapshot: Lazy load file store attributes cache<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/eclip.se\/578707\">578707<\/a> [checkout] Use .gitattributes from the commit to be checked out<\/li>\n<li><a href=\"https:\/\/eclip.se\/578852\">578852<\/a> [push] Call the pre-push hook later in the push process<\/li>\n<li>Prevent that an instance of PushCommand is reused<\/li>\n<li><a href=\"https:\/\/eclip.se\/578511\">578511<\/a> Stop initCause throwing in readAdvertisedRefs<\/li>\n<li><a href=\"https:\/\/eclip.se\/578546\">578546<\/a> Make sure to close Repository in tests<\/li>\n<li><a href=\"https:\/\/eclip.se\/578544\">578544<\/a> Fix resource leak in CancellableDigestOutputStreamTest<\/li>\n<li><a href=\"https:\/\/eclip.se\/513726\">513726<\/a> RebaseCommand: fix commit message in \"fixup\" case<\/li>\n<li>reftable: close old Db in FileRepository#convertToPackedRefs<\/li>\n<li><a href=\"https:\/\/eclip.se\/578454\">578454<\/a> reftable: Reload the stack _before_ trying to delete the files. This ensures we don't trip over our own open file handles when deleting compacted tables.<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix EolRepositoryTest for eol=native<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> Fix FS_Win32 if a non-directory is listed<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix ConfigTest for Windows<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix CommitTemplateConfigTest for Windows<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] RepoCommandTest: guard tests for executable files<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix closing of test repositories<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] DirCacheCheckoutTest: fix test expectation for eol=native<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix a Windows-only test in CheckoutCommandTest<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix ApplyCommandTest for Windows<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix OpenSshConfigFileTest for Windows<\/li>\n<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> BinaryHunkInputStream: accept CR-LF<\/li>\n<li><a href=\"https:\/\/eclip.se\/548529\">548529<\/a> Merge conflict messages: prefix conflict lines with a hash<\/li>\n<li><a href=\"https:\/\/eclip.se\/578458\">578458<\/a> ObjectWalk: close ObjectReader on close() if needed<\/li>\n<li><a href=\"https:\/\/eclip.se\/578313\">578313<\/a> LFS: Fix error occurring during delete branch<\/li>\n<li>[errorprone] Fix InfiniteRecursion error in RecordingLogger<\/li>\n<li><a href=\"https:\/\/eclip.se\/577545\">577545<\/a> sshd: backport upstream fix for SSHD-1231<\/li>\n<li><a href=\"https:\/\/eclip.se\/577983\">577983<\/a> Use FileSnapshot without using configs for FileBasedConfig<\/li>\n<li><a href=\"https:\/\/eclip.se\/577227\">577227<\/a> TreeRevFilter: fix wrong stop when the given path disappears<\/li>\n<li>storage: file: De-duplicate File.exists()+File.isFile()<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>update DEPENDENCIES for 6.1.0 release<\/li>\n<li>update Orbit to R20220302172233 for 2022-03<\/li>\n<li>update com.google.gson to 2.8.9.v20220111-1409<\/li>\n<li>update org.bouncycastle.bcpg to 1.70.0.v20220105-1522<\/li>\n<li>update org.bouncycastle.bcpkix to 1.70.0.v20220105-1522<\/li>\n<li>update org.bouncycastle.bcprov to 1.70.0.v20220105-1522<\/li>\n<li>update org.bouncycastle.bcutil to 1.70.0.v20220105-1522<\/li>\n<li>update org.apache.maven.wagon:wagon-ssh to 3.5.1<\/li>\n<li>update org.eclipse.jdt:ecj to 3.28.0<\/li>\n<li>update org.osgi:org.osgi.core to 6.0.0<\/li>\n<li>update Apache MINA sshd to 2.8.0<\/li>\n<li>update com.google.gson to 2.8.8.v20211029-0838<\/li>\n<li>update javaewah to 1.1.13.v20211029-0839<\/li>\n<li>update net.i2p.crypto.eddsa to 0.3.0.v20210923-1401<\/li>\n<li>update org.apache.ant to 1.10.12.v20211102-1452<\/li>\n<li>update org.apache.commons.compress to 1.21.0.v20211103-2100<\/li>\n<li>update org.bouncycastle.bcprov to 1.69.0.v20210923-1401<\/li>\n<li>update org.junit to 4.13.2.v20211018-1956<\/li>\n<li>complete update to servlet api 4.0.0<\/li>\n<li>update build-helper-maven-plugin to 3.2.0<\/li>\n<li>update jacoco-maven-plugin to 0.8.7<\/li>\n<li>update maven-antrun-plugin to 3.0.0<\/li>\n<li>update maven-dependency-plugin to 3.2.0<\/li>\n<li>update maven-enforcer-plugin to 3.0.0<\/li>\n<li>update maven-jar-plugin to 3.2.0<\/li>\n<li>update maven-javadoc-plugin to 3.3.1<\/li>\n<li>update maven-jxr-plugin to 3.1.1<\/li>\n<li>update maven-pmd-plugin to 3.15.0<\/li>\n<li>update maven-project-info-reports-plugin to 3.1.2<\/li>\n<li>update maven-resources-plugin to 3.2.0<\/li>\n<li>update maven-shade-plugin to 3.2.4<\/li>\n<li>update maven-site-plugin to 3.9.1<\/li>\n<li>update maven-source-plugin to 3.2.1<\/li>\n<li>update maven-surefire-plugin to 3.0.0-M5<\/li>\n<li>update spotbugs-maven-plugin to 4.3.0<\/li>\n<li>update tycho and tycho-extras to 2.5.0<\/li>\n<li>update eclipse-jarsigner-plugin to 1.3.2<\/li>\n<li>RepoCommand: Move bare\/regular superproject writing to their own classes<\/li>\n<li>Bazel: Include bazel resource configuration file for RBE build<\/li>\n<li>Bazel: Add RBE support<\/li>\n<li>Bazel: Switch to using toolchain resolution for java rules<\/li>\n<li>Bazel: Simplify java 11 toolchain definition<\/li>\n<li>Bazel: Remove JDK 15 toolchain definition<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/eclip.se\/353405\">353405<\/a> [push] support the &quot;matching&quot; RefSpecs &quot;:&quot; and &quot;+:&quot;<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/565251\">565251<\/a> IndexDiff: use tree filter also for SubmoduleWalk<\/li>\r\n\t<li>Describe: add support for core.abbrev config option<\/li>\r\n\t<li>Add a typed config getter for integers confined to a range<\/li>\r\n\t<li>PersonIdent: Add ctors that accept Instant in addition to Date<\/li>\r\n\t<li>Cap describe abbrev option, minimum is 4, maximum is length of a full ObjectId<\/li>\r\n\t<li>DescribeCommand: Add support for --abbrev=0<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/537883\">537883<\/a> DescribeCommand: Support configuring the hash abbreviation<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578676\">578676<\/a> PushCommand: determine remote from git config if not given<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/351314\">351314<\/a> PushCommand: consider push.default when no RefSpecs are given<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/351314\">351314<\/a> Support for git config push.default<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578020\">578020<\/a> Support for &quot;lfs.url&quot; from &quot;.lfsconfig&quot;<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578621\">578621<\/a> Support LFS Server URL without .git suffix<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/440211\">440211<\/a> [rebase] Enable users to have a Change-ID be generated when squashing or rewording commits.<\/li>\r\n\t<li>RepoCommand: Add API to set extra files in the destination repository<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578173\">578173<\/a> RebaseCommand: better commit message rewording. Respect git config commit.cleanup for rewording.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553065\">553065<\/a> CommitCommand: implement git commit --cleanup.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553065\">553065<\/a> Provide git config commit.cleanup<\/li>\r\n\t<li>sshd: support the ConnectTimeout ssh config<\/li>\r\n\t<li>sshd: Skip unknown keys from the SSH agent<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577052\">577052<\/a> sshd: support the AddKeysToAgent ssh config<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> sshd: handle &quot;IdentityAgent SSH_AUTH_SOCK&quot; in ssh config<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> sshd: Connector for the Win32-OpenSSH SSH agent<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> sshd: handle IdentitiesOnly with an SSH agent<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577053\">577053<\/a> shd: support IdentityAgent config<\/li>\r\n\t<li>DFS block cache: report index load and evict stats<\/li>\r\n\t<li>Use slf4j-simple instead of log4j for logging<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/356832\">356832<\/a> Add config reader for user-defined difftools<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/356832\">356832<\/a> Add command line support for &quot;git difftool&quot;<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Transport: load all refs only if push refspecs have wildcards<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577937\">577937<\/a> UploadPack v2 protocol: Stop negotiation for orphan refs<\/li>\r\n\t<li>PackBitmapIndexV1: support parallel loading of reverse index<\/li>\r\n\t<li>RefDirectory.scanRef: Re-use file existence check done in snapshot creation<\/li>\r\n\t<li>FileSnapshot: Lazy load file store attributes cache<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/eclip.se\/578707\">578707<\/a>&nbsp;[checkout] Use .gitattributes from the commit to be checked out<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578852\">578852<\/a> [push] Call the pre-push hook later in the push process<\/li>\r\n\t<li>Prevent that an instance of PushCommand is reused<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578511\">578511<\/a> Stop initCause throwing in readAdvertisedRefs<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578546\">578546<\/a> Make sure to close Repository in tests<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578544\">578544<\/a> Fix resource leak in CancellableDigestOutputStreamTest<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/513726\">513726<\/a> RebaseCommand: fix commit message in &quot;fixup&quot; case<\/li>\r\n\t<li>reftable: close old Db in FileRepository#convertToPackedRefs<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578454\">578454<\/a> reftable: Reload the stack _before_ trying to delete the files. This ensures we don&#39;t trip over our own open file handles when deleting compacted tables.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix EolRepositoryTest for eol=native<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> Fix FS_Win32 if a non-directory is listed<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix ConfigTest for Windows<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix CommitTemplateConfigTest for Windows<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] RepoCommandTest: guard tests for executable files<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix closing of test repositories<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] DirCacheCheckoutTest: fix test expectation for eol=native<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix a Windows-only test in CheckoutCommandTest<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix ApplyCommandTest for Windows<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> [test] Fix OpenSshConfigFileTest for Windows<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/550111\">550111<\/a> BinaryHunkInputStream: accept CR-LF<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/548529\">548529<\/a> Merge conflict messages: prefix conflict lines with a hash<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578458\">578458<\/a> ObjectWalk: close ObjectReader on close() if needed<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/578313\">578313<\/a> LFS: Fix error occurring during delete branch<\/li>\r\n\t<li>[errorprone] Fix InfiniteRecursion error in RecordingLogger<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577545\">577545<\/a> sshd: backport upstream fix for SSHD-1231<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577983\">577983<\/a> Use FileSnapshot without using configs for FileBasedConfig<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/577227\">577227<\/a> TreeRevFilter: fix wrong stop when the given path disappears<\/li>\r\n\t<li>storage: file: De-duplicate File.exists()+File.isFile()<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>update DEPENDENCIES for 6.1.0 release<\/li>\r\n\t<li>update Orbit to R20220302172233 for 2022-03<\/li>\r\n\t<li>update com.google.gson to 2.8.9.v20220111-1409<\/li>\r\n\t<li>update org.bouncycastle.bcpg to 1.70.0.v20220105-1522<\/li>\r\n\t<li>update org.bouncycastle.bcpkix to 1.70.0.v20220105-1522<\/li>\r\n\t<li>update org.bouncycastle.bcprov to 1.70.0.v20220105-1522<\/li>\r\n\t<li>update org.bouncycastle.bcutil to 1.70.0.v20220105-1522<\/li>\r\n\t<li>update org.apache.maven.wagon:wagon-ssh to 3.5.1<\/li>\r\n\t<li>update org.eclipse.jdt:ecj to 3.28.0<\/li>\r\n\t<li>update org.osgi:org.osgi.core to 6.0.0<\/li>\r\n\t<li>update Apache MINA sshd to 2.8.0<\/li>\r\n\t<li>update com.google.gson to 2.8.8.v20211029-0838<\/li>\r\n\t<li>update javaewah to 1.1.13.v20211029-0839<\/li>\r\n\t<li>update net.i2p.crypto.eddsa to 0.3.0.v20210923-1401<\/li>\r\n\t<li>update org.apache.ant to 1.10.12.v20211102-1452<\/li>\r\n\t<li>update org.apache.commons.compress to 1.21.0.v20211103-2100<\/li>\r\n\t<li>update org.bouncycastle.bcprov to 1.69.0.v20210923-1401<\/li>\r\n\t<li>update org.junit to 4.13.2.v20211018-1956<\/li>\r\n\t<li>complete update to servlet api 4.0.0<\/li>\r\n\t<li>update build-helper-maven-plugin to 3.2.0<\/li>\r\n\t<li>update jacoco-maven-plugin to 0.8.7<\/li>\r\n\t<li>update maven-antrun-plugin to 3.0.0<\/li>\r\n\t<li>update maven-dependency-plugin to 3.2.0<\/li>\r\n\t<li>update maven-enforcer-plugin to 3.0.0<\/li>\r\n\t<li>update maven-jar-plugin to 3.2.0<\/li>\r\n\t<li>update maven-javadoc-plugin to 3.3.1<\/li>\r\n\t<li>update maven-jxr-plugin to 3.1.1<\/li>\r\n\t<li>update maven-pmd-plugin to 3.15.0<\/li>\r\n\t<li>update maven-project-info-reports-plugin to 3.1.2<\/li>\r\n\t<li>update maven-resources-plugin to 3.2.0<\/li>\r\n\t<li>update maven-shade-plugin to 3.2.4<\/li>\r\n\t<li>update maven-site-plugin to 3.9.1<\/li>\r\n\t<li>update maven-source-plugin to 3.2.1<\/li>\r\n\t<li>update maven-surefire-plugin to 3.0.0-M5<\/li>\r\n\t<li>update spotbugs-maven-plugin to 4.3.0<\/li>\r\n\t<li>update tycho and tycho-extras to 2.5.0<\/li>\r\n\t<li>update eclipse-jarsigner-plugin to 1.3.2<\/li>\r\n\t<li>RepoCommand: Move bare\/regular superproject writing to their own classes<\/li>\r\n\t<li>Bazel: Include bazel resource configuration file for RBE build<\/li>\r\n\t<li>Bazel: Add RBE support<\/li>\r\n\t<li>Bazel: Switch to using toolchain resolution for java rules<\/li>\r\n\t<li>Bazel: Simplify java 11 toolchain definition<\/li>\r\n\t<li>Bazel: Remove JDK 15 toolchain definition<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/6.1"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/6.1.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-12-08 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p><strong>Prerequisites<\/strong><\/p>\n<ul><li>JGit 6.0 requires at least Java 11 to run<\/li>\n<\/ul><p><strong>Features<\/strong><\/p>\n<ul><li><a href=\"https:\/\/eclip.se\/446355\">446355<\/a> Support <em>commit.template<\/em> git config option<\/li>\n<li>ssh: Handle \"ProxyJump none\" from SSH config file<\/li>\n<li>OpenSshConfigFile: update handling of line comments and quoted strings following changes in OpenSSH<\/li>\n<li>OpenSshConfigFile: update token replacements. It appears that the <a href=\"https:\/\/man.openbsd.org\/ssh_config.5#TOKENS\">OpenSSH documentation has changed<\/a>; it now allows more flags for a number of keys.<\/li>\n<li>[sshd agent] Introduce ConnectorDescriptor<\/li>\n<li>Simplify SshdFtpChannel<\/li>\n<li><a href=\"https:\/\/eclip.se\/541274\">541274<\/a>, <a href=\"https:\/\/eclip.se\/541275\">541275<\/a> sshd: add support for ssh-agent. Add a simple SSH agent connector using JNA. Include com.sum.jna and com.sun.jna.platform in the target platform. JNA is used to communicate through Unix domain sockets with ssh-agent, and if on Windows, to communicate via shared memory with Pageant. The new bundle o.e.j.ssh.apache.agent is an OSGi fragment so that the java.util.ServiceLoader can find the provided factory without further ado in OSGi environments. Adapt both maven and bazel builds to include the new bundle.    Manually tested on OS X, CentOS 7, and Win10 with Pageant 0.76.<\/li>\n<li><a href=\"https:\/\/eclip.se\/576971\">576971<\/a> Binary and CR-LF detection: lone CRs -&gt; binary. C git considers not only files containing NUL bytes as binary but also files containing lone CRs. Implement this also for JGit. C git additionally counts printable vs. non-printable characters and considers files that have non_printable_count &gt; printable_count \/ 128 also as binary. This is not implemented because such counting probably only makes sense if one looks at the full file or blob content. The Auto[CR]LF* streams in JGit look only at the first few KiB of a stream in order not to buffer too much.<\/li>\n<li><a href=\"https:\/\/eclip.se\/576971\">576971<\/a> Make the buffer size for text\/binary detection configurable<\/li>\n<li>GarbageCollectCommand: add numberOfBitmaps to statistics<\/li>\n<\/ul><p><strong>API cleanup<\/strong><\/p>\n<ul><li>Don't block in GC#gc until garbage collection finished. Let GC#gc return collection of newly created packs as CompletableFuture to enable using gc() asynchronously.<\/li>\n<li><a href=\"https:\/\/eclip.se\/549777\">549777<\/a> Let ObjectDatabase implement AutoClosable<\/li>\n<li><a href=\"https:\/\/eclip.se\/576340\">576340<\/a> [6.0 API cleanup] Public interface for PackLock. Provide a public interface PackLock exposing only the unlock() method. Rename the internal PackLock class to PackLockImpl and have it implement the new interface.<\/li>\n<li><a href=\"https:\/\/eclip.se\/576340\">576340<\/a> [6.0 API cleanup] StoredObjectRepresentationNotAvailableException. Remove the unused parameter, which had a non-API type anyway.<\/li>\n<li>RepoCommand: Do not wrap GitApiExceptions in GitApiExceptions. While building the commit for the destination project, RepoCommand catches GitApiExceptions and wraps them into ManifestErrorException (a subclass of GitApiException). This hides the real exception from the caller and prevent them to do a fine-grained catch. Specifically this is problematic for gerrit's supermanifest plugin, that won't see ConcurrentRefUpdate exceptions to detect lock-failures. Use ManifestErrorException to wrap non-GitApiExceptions, let GitApiExceptions pass through as they are.<\/li>\n<li>[6.0 API cleanup] CancelledException vs. CanceledException. Use the GitAPIException CanceledException instead of IOExceptionCancelledException in the rename detector.<\/li>\n<li><a href=\"https:\/\/eclip.se\/564544\">564544<\/a> Fix split package in bundle org.eclipse.jgit.ssh.jsch<\/li>\n<li><a href=\"https:\/\/eclip.se\/553116\">553116<\/a> Enable CommitCommand to use a fluent style<\/li>\n<\/ul><p><strong>Performance Improvements<\/strong><\/p>\n<ul><li>Make BinaryBlobException stackless<\/li>\n<li>DFS block cache: allow multiple passes for blocks before eviction<\/li>\n<li>Optimize RevWalk.getMergedInto()<\/li>\n<\/ul><p><strong>Bug Fixes<\/strong><\/p>\n<ul><li><a href=\"https:\/\/eclip.se\/577492\">577492<\/a> FS: debug logging only if system config file cannot be found<\/li>\n<li>AppServer: fix keystore used to setup test SSL context factory<\/li>\n<li><a href=\"https:\/\/eclip.se\/576604\">576604<\/a> Set JSch global config values only if not set already<\/li>\n<li><a href=\"https:\/\/eclip.se\/577358\">577358<\/a> Better git system config finding. We've used <em>\"GIT_EDITOR=edit git config --system --edit\"<\/em> to determine the location of the git system config for a long time. But git 2.34.0 always expects this command to have a TTY, but there isn't one when called from Java. If there isn't one, the Java process may get a SIGTTOU from the child process and hangs. Arguably it's a bug in C git 2.34.0 to unconditionally assume there was a tty. But JGit needs a fix *now*, otherwise any application using JGit will lock up if git 2.34.0 is installed on the machine. Therefore, use a different approach if the C git found is 2.8.0 or newer: parse the output of<br \/><em>git config --system --show-origin --list -z<\/em><\/li>\n<li>DFS block cache: harden against race over ref locks.<\/li>\n<li>ssh: use a single SecureRandom instance for hashing hostnames<\/li>\n<li><a href=\"https:\/\/eclip.se\/575393\">575393<\/a> Fix checkout of files with mixed line endings on text=auto eol=crlf<\/li>\n<li>Don't rely on an implicit default character set. JEP 400 (Java 18) will change the default character set to UTF-8 unconditionally. Introduce SystemReader.getDefaultCharset() that provides the locale-dependent charset the way JEP 400 recommends.<\/li>\n<li>DFS block cache: fix lock issue and support parallel index loading<\/li>\n<li>JSch: fix service publication for ServiceLoader<\/li>\n<li>Fix missing peel-part in lsRefsV2 for loose annotated tags<\/li>\n<li>Fix RevWalk.getMergedInto() ignores annotated tags<\/li>\n<li><a href=\"https:\/\/eclip.se\/573638\">573638<\/a> KeyGrip: fix build error on java 15<\/li>\n<li><a href=\"https:\/\/eclip.se\/576250\">576250<\/a> reftable: drop code for truncated reads<\/li>\n<li>reftable: pass on invalid object ID in conversion<\/li>\n<li>Fix running benchmarks from bazel<\/li>\n<\/ul><p><strong>Build and Release Engineering<\/strong><\/p>\n<ul><li>Implement RecordingLogger based on org.slf4j.Logger<\/li>\n<li>Add 4.22 target platform for 2021-12<\/li>\n<li>Update Orbit to R20211122181901 for 2021-12<\/li>\n<li>Skip javadoc generation for test bundles.<\/li>\n<li>Add missing .gitignore in o.e.j.ssh.apache.agent<\/li>\n<li>[test] test OpenSshConfigFile directly, not via the JSch config<\/li>\n<li>[releng] bazel: Enable errorprone on o.e.j.ssh.apache<\/li>\n<li>[doc] Add README and package-info to the SSH bundles<\/li>\n<\/ul><ul><li>Factor out parsing git-style size numbers to StringUtils<\/li>\n<li><a href=\"https:\/\/eclip.se\/534731\">534731<\/a> Remove use of deprecated getAllRefs() in UploadPack<\/li>\n<\/ul><p>Build<\/p>\n<ul><li>Upgrade plexus-compiler version to 2.9.0<\/li>\n<li>Update tycho to 2.5.0 and target platform to jgit-4.17<\/li>\n<li>Remove pack200 which is deprecated in Java 11 and isn't supported by tycho 2.5.0 anymore. It was specified in JSR 200 (J2SE 1.5), deprecated in JEP 336 (Java SE 11) and removed in JEP 367 (Java SE 14).<\/li>\n<li>Update ecj to 3.27.0<\/li>\n<li>Update errorprone to 2.9.0 and enable using it on java 16<\/li>\n<li>update maven-enforcer-plugin 3.0.0<\/li>\n<li>update maven-javadoc-plugin 3.3.1<\/li>\n<li>update maven-pmd-plugin 3.15.0<\/li>\n<li>update org.eclipse.cbi.maven.plugins:eclipse-jarsigner-plugin 1.3.2<\/li>\n<li>update org.springframework.boot:spring-boot-maven-plugin 2.5.4<\/li>\n<li><a href=\"https:\/\/eclip.se\/575621\">575621<\/a> Add org.bouncycastle.bcutil to p2 repository<\/li>\n<\/ul><p>Update to Java 11<\/p>\n<ul><li><a href=\"https:\/\/eclip.se\/569917\">569917<\/a> Bump minimum required Java version to 11<\/li>\n<li>[releng] Make the bazel build use Java 11<\/li>\n<li>Update the baseline target platform to jgit-4.17 corresponding to Eclipse 4.17 (2020-09). Delete all target platforms older than this version and the corresponding Orbit releases.<\/li>\n<li>Replace XMLReaderFactory deprecated since Java 9<\/li>\n<li>IndexDiffWithSymlinkTest: handle InaccessibleObjectException<\/li>\n<li>Enable using JMH annotation processor on Java&gt;=9<\/li>\n<li>Enable compiler option --release<\/li>\n<\/ul><p>Dependencies<\/p>\n<ul><li><a href=\"https:\/\/eclip.se\/571932\">571932<\/a>, <a href=\"https:\/\/eclip.se\/576100\">576100<\/a> Update Jetty to 10.0.6<\/li>\n<li>Update servlet-api to 4.0<\/li>\n<li>Update com.google.gson to 2.8.8.v20211029-0838<\/li>\n<li>Update com.googlecode.javaewah to 1.1.13.v20211029-0839<\/li>\n<li>Update net.i2p.crypto.eddsa to 0.3.0.v20210923-1401<\/li>\n<li>Update org.apache.ant to 1.10.12.v20211102-1452<\/li>\n<li>Update org.apache.commons.compress to 1.21.0.v20211103-2100<\/li>\n<li>Update org.bouncycastle.bcprov to 1.69.0.v20210923-1401<\/li>\n<li>Update org.junit to 4.13.2.v20211018-1956<\/li>\n<\/ul>","summary":"","value":"<p><strong>Prerequisites<\/strong><\/p><ul><li>JGit 6.0 requires at least Java 11 to run<\/li><\/ul><p><strong>Features<\/strong><\/p><ul><li><a href=\"https:\/\/eclip.se\/446355\">446355<\/a> Support <em>commit.template<\/em> git config option<\/li><li>ssh: Handle &quot;ProxyJump none&quot; from SSH config file<\/li><li>OpenSshConfigFile: update handling of line comments and quoted strings following changes in OpenSSH<\/li><li>OpenSshConfigFile: update token replacements. It appears that the <a href=\"https:\/\/man.openbsd.org\/ssh_config.5#TOKENS\">OpenSSH documentation has changed<\/a>; it now allows&nbsp;more flags for a number of keys.<\/li><li>[sshd agent] Introduce ConnectorDescriptor<\/li><li>Simplify SshdFtpChannel<\/li><li><a href=\"https:\/\/eclip.se\/541274\">541274<\/a>, <a href=\"https:\/\/eclip.se\/541275\">541275<\/a> sshd: add support for ssh-agent. Add a simple SSH agent connector using JNA. Include com.sum.jna and&nbsp;com.sun.jna.platform in the target platform. JNA is used to communicate through Unix domain sockets with ssh-agent,&nbsp;and if on Windows, to communicate via shared memory with Pageant. The new bundle o.e.j.ssh.apache.agent is an OSGi fragment so that&nbsp;the java.util.ServiceLoader can find the provided factory without&nbsp;further ado in OSGi environments. Adapt both maven and bazel builds to include the new bundle.&nbsp; &nbsp; Manually tested on OS X, CentOS 7, and Win10 with Pageant 0.76.<\/li><li><a href=\"https:\/\/eclip.se\/576971\">576971<\/a> Binary and CR-LF detection: lone CRs -&gt; binary. C git considers not only files containing NUL bytes as binary but also&nbsp;files containing lone CRs. Implement this also for JGit. C git additionally counts printable vs. non-printable characters and&nbsp;considers files that have non_printable_count &gt; printable_count \/ 128&nbsp;also as binary. This is not implemented because such counting probably&nbsp;only makes sense if one looks at the full file or blob content. The&nbsp;Auto[CR]LF* streams in JGit look only at the first few KiB of a stream in order not to buffer too much.<\/li><li><a href=\"https:\/\/eclip.se\/576971\">576971<\/a> Make the buffer size for text\/binary detection configurable<\/li><li>GarbageCollectCommand: add numberOfBitmaps to statistics<\/li><\/ul><p><strong>API cleanup<\/strong><\/p><ul><li>Don&#39;t block in GC#gc until garbage collection finished. Let GC#gc return collection of newly created packs as CompletableFuture&nbsp;to enable using gc() asynchronously.<\/li><li><a href=\"https:\/\/eclip.se\/549777\">549777<\/a> Let ObjectDatabase implement AutoClosable<\/li><li><a href=\"https:\/\/eclip.se\/576340\">576340<\/a> [6.0 API cleanup] Public interface for PackLock. Provide a public interface PackLock exposing only the unlock() method.&nbsp;Rename the internal PackLock class to PackLockImpl and have it implement the new interface.<\/li><li><a href=\"https:\/\/eclip.se\/576340\">576340<\/a> [6.0 API cleanup] StoredObjectRepresentationNotAvailableException. Remove the unused parameter, which had a non-API type anyway.<\/li><li>RepoCommand: Do not wrap GitApiExceptions in GitApiExceptions. While building the commit for the destination project, RepoCommand&nbsp;catches GitApiExceptions and wraps them into ManifestErrorException (a subclass of GitApiException). This hides the real exception from the&nbsp;caller and prevent them to do a fine-grained catch. Specifically this is problematic for gerrit&#39;s supermanifest plugin, that&nbsp;won&#39;t see ConcurrentRefUpdate exceptions to detect lock-failures.&nbsp;Use ManifestErrorException to wrap non-GitApiExceptions, let GitApiExceptions pass through as they are.<\/li><li>[6.0 API cleanup] CancelledException vs. CanceledException. Use the GitAPIException CanceledException instead of IOExceptionCancelledException in the rename detector.<\/li><li><a href=\"https:\/\/eclip.se\/564544\">564544<\/a> Fix split package in bundle org.eclipse.jgit.ssh.jsch<\/li><li><a href=\"https:\/\/eclip.se\/553116\">553116<\/a> Enable CommitCommand to use a fluent style<\/li><\/ul><p><strong>Performance Improvements<\/strong><\/p><ul><li>Make BinaryBlobException stackless<\/li><li>DFS block cache: allow multiple passes for blocks before eviction<\/li><li>Optimize RevWalk.getMergedInto()<\/li><\/ul><p><strong>Bug Fixes<\/strong><\/p><ul><li><a href=\"https:\/\/eclip.se\/577492\">577492<\/a> FS: debug logging only if system config file cannot be found<\/li><li>AppServer: fix keystore used to setup test SSL context factory<\/li><li><a href=\"https:\/\/eclip.se\/576604\">576604<\/a> Set JSch global config values only if not set already<\/li><li><a href=\"https:\/\/eclip.se\/577358\">577358<\/a> Better git system config finding. We&#39;ve used <em>&quot;GIT_EDITOR=edit git config --system --edit&quot;<\/em> to determine the location of the git system config for a long time. But git 2.34.0 always expects this command to have a TTY, but there isn&#39;t one when&nbsp;called from Java. If there isn&#39;t one, the Java process may get a SIGTTOU from the child process and hangs.&nbsp;Arguably it&#39;s a bug in C git 2.34.0 to unconditionally assume there was a tty. But JGit needs a fix *now*, otherwise any application using&nbsp;JGit will lock up if git 2.34.0 is installed on the machine. Therefore, use a different approach if the C git found is 2.8.0 or&nbsp;newer: parse the output of<br \/><em>git config --system --show-origin --list -z<\/em><\/li><li>DFS block cache: harden against race over ref locks.<\/li><li>ssh: use a single SecureRandom instance for hashing hostnames<\/li><li><a href=\"https:\/\/eclip.se\/575393\">575393<\/a> Fix checkout of files with mixed line endings on text=auto eol=crlf<\/li><li>Don&#39;t rely on an implicit default character set. JEP 400 (Java 18) will change the default character set to UTF-8 unconditionally. Introduce SystemReader.getDefaultCharset() that&nbsp;provides the locale-dependent charset the way JEP 400 recommends.<\/li><li>DFS block cache: fix lock issue and support parallel index loading<\/li><li>JSch: fix service publication for ServiceLoader<\/li><li>Fix missing peel-part in lsRefsV2 for loose annotated tags<\/li><li>Fix RevWalk.getMergedInto() ignores annotated tags<\/li><li><a href=\"https:\/\/eclip.se\/573638\">573638<\/a> KeyGrip: fix build error on java 15<\/li><li><a href=\"https:\/\/eclip.se\/576250\">576250<\/a> reftable: drop code for truncated reads<\/li><li>reftable: pass on invalid object ID in conversion<\/li><li>Fix running benchmarks from bazel<\/li><\/ul><p><strong>Build and Release Engineering<\/strong><\/p><ul><li>Implement RecordingLogger based on org.slf4j.Logger<\/li><li>Add 4.22 target platform for 2021-12<\/li><li>Update Orbit to R20211122181901 for 2021-12<\/li><li>Skip javadoc generation for test bundles.<\/li><li>Add missing .gitignore in o.e.j.ssh.apache.agent<\/li><li>[test] test OpenSshConfigFile directly, not via the JSch config<\/li><li>[releng] bazel: Enable errorprone on o.e.j.ssh.apache<\/li><li>[doc] Add README and package-info to the SSH bundles<\/li><\/ul><ul><li>Factor out parsing git-style size numbers to StringUtils<\/li><li><a href=\"https:\/\/eclip.se\/534731\">534731<\/a> Remove use of deprecated getAllRefs() in UploadPack<\/li><\/ul><p>Build<\/p><ul><li>Upgrade plexus-compiler version to 2.9.0<\/li><li>Update tycho to 2.5.0 and target platform to jgit-4.17<\/li><li>Remove pack200 which is deprecated in Java 11 and isn&#39;t supported by tycho 2.5.0 anymore. It was specified in JSR 200 (J2SE 1.5),&nbsp;deprecated in JEP 336 (Java SE 11) and removed in JEP 367 (Java SE 14).<\/li><li>Update ecj to 3.27.0<\/li><li>Update errorprone to 2.9.0 and enable using it on java 16<\/li><li>update maven-enforcer-plugin 3.0.0<\/li><li>update maven-javadoc-plugin 3.3.1<\/li><li>update maven-pmd-plugin 3.15.0<\/li><li>update org.eclipse.cbi.maven.plugins:eclipse-jarsigner-plugin 1.3.2<\/li><li>update org.springframework.boot:spring-boot-maven-plugin 2.5.4<\/li><li><a href=\"https:\/\/eclip.se\/575621\">575621<\/a> Add org.bouncycastle.bcutil to p2 repository<\/li><\/ul><p>Update to Java 11<\/p><ul><li><a href=\"https:\/\/eclip.se\/569917\">569917<\/a> Bump minimum required Java version to 11<\/li><li>[releng] Make the bazel build use Java 11<\/li><li>Update the baseline target platform to jgit-4.17 corresponding to Eclipse 4.17 (2020-09). Delete all target platforms older than this version and the corresponding Orbit releases.<\/li><li>Replace XMLReaderFactory deprecated since Java 9<\/li><li>IndexDiffWithSymlinkTest: handle InaccessibleObjectException<\/li><li>Enable using JMH annotation processor on Java&gt;=9<\/li><li>Enable compiler option --release<\/li><\/ul><p>Dependencies<\/p><ul><li><a href=\"https:\/\/eclip.se\/571932\">571932<\/a>, <a href=\"https:\/\/eclip.se\/576100\">576100<\/a> Update Jetty to 10.0.6<\/li><li>Update servlet-api to 4.0<\/li><li>Update com.google.gson to 2.8.8.v20211029-0838<\/li><li>Update com.googlecode.javaewah to 1.1.13.v20211029-0839<\/li><li>Update net.i2p.crypto.eddsa to 0.3.0.v20210923-1401<\/li><li>Update org.apache.ant to 1.10.12.v20211102-1452<\/li><li>Update org.apache.commons.compress to 1.21.0.v20211103-2100<\/li><li>Update org.bouncycastle.bcprov to 1.69.0.v20210923-1401<\/li><li>Update org.junit to 4.13.2.v20211018-1956<\/li><\/ul>"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/6.0"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/6.0.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-09-15 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>GitServlet: allow to override default error handlers<\/li>\n<li>transport: add object-info capability that allows clients to query the remote server for object metadata (currently only size). This is a backport of the same capability that was recently added to the Git project in commit a2ba162cda.<\/li>\n<li>DFS block cache: add additional stats to DfsReaderIoStats providing details about loading pack, bitmap and reverse indexes.<\/li>\n<li><a href=\"https:\/\/eclip.se\/575327\">575327<\/a> [gpg] Better GPG home directory determination\n<ul><li>GPG can use customized directories instead of the standard ~\/.gnupg or %APPDATA%\\gnupg directories:\n<ul><li>Environment variable GNUPGHOME can define the location.<\/li>\n<li>On Windows, a registry key may define the location (but this is deprecated).<\/li>\n<li>Portable installations may use a directory defined via a file \"gpgconf.ctl\".<\/li>\n<li> GPG programs may take a --homedir command-line argument, which overrides anything.<\/li>\n<\/ul><\/li>\n<li>Implement handling of environment variable GNUPGHOME. The other ways of GPG to get its home directory are outside the reach of JGit. Provide a system property \"jgit.gpg.home\" that the user can set in such cases.<\/li>\n<li>Do tilde replacement for the system property and for GNUPGHOME.<\/li>\n<li>Note that on VMS, the default directory would be ~\/gnupg (without dot). This is not accounted for, but a user on VMS could now use either the system property or GNUPGHOME to direct JGit to the right directory.<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/eclip.se\/446355\">446355<\/a> Support commit.template config property<\/li>\n<li><a href=\"https:\/\/eclip.se\/574635\">574635<\/a> [sshd] Distinguish key type and signature algorithm for host key<\/li>\n<li><a href=\"https:\/\/eclip.se\/574636\">574636<\/a> [sshd] Implement SSH config KexAlgorithms\n<ul><li>Make the used KEX algorithms configurable via the ssh config.<\/li>\n<li>Also implement adding algorithms not in the default set: since sshd 2.6.0 deprecated SHA1-based algorithms, it is possible that the default set has not all available algorithms, so adding algorithms makes sense. This enables users who have to use a git server that only supports old SHA1-based key exchange methods to enable those methods in the ssh config: <br \/>\n\t\t\"KexAlgorithms +diffie-hellman-group1-sha1\"<\/li>\n<li>There are two more SHA1 algorithms that are not enabled by default: diffie-hellman-group14-sha1 and diffie-hellman-group-exchange-sha1.<\/li>\n<li>KeyAlgorithms accepts a comma-separated list of algorithm names.<\/li>\n<li>[sshd] Log the full KEX negotiation result to help debugging KEX problems.<\/li>\n<\/ul><\/li>\n<li>Teach independent negotiation (no pack file) using an option \"wait-for-done\"\n<ul><li>From Git commit 9c1e657a8f:\n<ul><li>Currently, the packfile negotiation step within a Git fetch cannot be done independent of sending the packfile, even though there is at least one application wherein this is useful - push negotiation. Therefore, make it possible for this negotiation step to be done independently.<\/li>\n<li>This feature is for protocol v2 only.<\/li>\n<li>In the protocol, the main hindrance towards independent negotiation is that the server can unilaterally decide to send the packfile. This is solved by a \"wait-for-done\" argument: the server will then wait for the client to say \"done\". In practice, the client will never say it; instead it will cease requests once it is satisfied.<\/li>\n<li>Advertising the server capability option \"wait-for-done\" is behind the transport config: \"uploadpack.advertisewaitfordone\", which by default is false.<\/li>\n<\/ul><\/li>\n<\/ul><\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li>UploadPack searchForReuse might impact performance in large repositories. The search for reuse phase for all the objects scans all the packfiles, looking for the best candidate to serve back to the client. This can lead to an expensive operation when the number of packfiles and objects is high. Add option \"pack.searchForReuseTimeout\" to limit the time spent on this search.<\/li>\n<li>BatchRefUpdate: Skip saving conflicting ref names and prefixes in memory improving the BatchRefUpdate performance from O(n^2) to O(1).<\/li>\n<li>Optimize RefDirectory.isNameConflicting() improving the name conflicting check from O(n^2) to O(1).<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/eclip.se\/575367\">575367<\/a> Ignore IllegalStateException if JVM is already shutting down<\/li>\n<li><a href=\"https:\/\/eclip.se\/575385\">575385<\/a> Ensure FS#searchPath only selects executable files<\/li>\n<li>Fix RevWalk#getMergedInto's result which was wrong on the second call<\/li>\n<li>[sshd] Ignore revoked keys in OpenSshServerKeyDatabase.lookup()<\/li>\n<li>[pgm] Fix default meta variable defined in StopOptionHandler<\/li>\n<li><a href=\"https:\/\/eclip.se\/573791\">573791<\/a> Retry loose object read upon \"Stale file handle\" exception<\/li>\n<li><a href=\"https:\/\/eclip.se\/574178\">574178<\/a> Fix garbage collection failing to delete pack file<\/li>\n<li><a href=\"https:\/\/eclip.se\/574253\">574253<\/a> Fix PathSuffixFilter: can decide only on full paths<\/li>\n<li>Fixing visibility for HostEntry constructors.<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<p>Update dependencies:<\/p>\n<ul><li>orbit to R20210825222808 for 2021-09<\/li>\n<li>assertj to 3.20.2.v20210706-1104<\/li>\n<li> com.google.gson to 2.8.7.v20210624-1215<\/li>\n<li>hamcrest to 2.2.0.v20210711-0821, junit 4.13 requires hamcrest-core and hamcrest-library 1.3 therefore keep them in the target platform<\/li>\n<li>javaewah to 1.1.12.v20210622-2206<\/li>\n<li>jetty to 9.4.43.v20210629<\/li>\n<li>JMH used in benchmarks to 1.32<\/li>\n<li>org.apache.commons.compress to 1.20.0.v20210713-19<\/li>\n<li><a href=\"https:\/\/eclip.se\/574220\">574220<\/a> org.apache.sshd.osgi to 2.7.0.v20210623-0618<\/li>\n<li><a href=\"https:\/\/eclip.se\/574220\">574220<\/a> org.apache.sshd.sftp to 2.7.0.v20210623-0618<\/li>\n<li>org.bouncycastle.bcpg to 1.69.0.v20210713-1924<\/li>\n<li>org.bouncycastle.bcpkix to 1.69.0.v20210713-1924<\/li>\n<li>org.bouncycastle.bcprov to 1.69.0.v20210713-1924<\/li>\n<li>org.bouncycastle.bcutil 1.69.0.v20210713-1924<\/li>\n<li>org.tukaani.xz to 1.9.0.v20210624-1259<\/li>\n<li>Relax version range for hamcrest and assertj<\/li>\n<\/ul><p>Update maven plugins:<\/p>\n<ul><li>jacoco-maven-plugin to 0.8.7<\/li>\n<li>maven-dependency-plugin to 3.2.0<\/li>\n<li>maven-jxr-plugin to 3.1.1<\/li>\n<li>spotbugs-maven-plugin to 4.3.0<\/li>\n<\/ul><p>Miscellaneous<\/p>\n<ul><li>[test] Create keystore with the keytool of the running JDK<\/li>\n<li>Add 4.21 target platform<\/li>\n<li>Update 4.20 target platform to use final 4.20 release<\/li>\n<li>Remove use of deprecated getAllRefs() in ReceivePack<\/li>\n<li>[releng] japicmp: update last release version to 5.12.0.202106070339-r.<\/li>\n<li>Update bazlets to react on Maven central no longer supporting http protocol but only https<\/li>\n<li>Update bazel version to 2.0<\/li>\n<li>bazel: don't expose jsch and jzlib to org.eclipse.jgit<\/li>\n<\/ul><h2>Documentation<\/h2>\n<ul><li>CONTRIBUTING: add explicit link to ECA<\/li>\n<li>CONTRIBUTING: Use standard markdown format<\/li>\n<li>Add Eclipse code of conduct and security policy<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>GitServlet: allow to override default error handlers<\/li>\r\n\t<li>transport: add object-info capability that allows clients to query the remote server for object metadata (currently only size). This&nbsp;is a backport of the same capability that was recently added to the Git project in commit a2ba162cda.<\/li>\r\n\t<li>DFS block cache: add additional stats to DfsReaderIoStats providing details about loading pack, bitmap and reverse indexes.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/575327\">575327<\/a> [gpg] Better GPG home directory determination\r\n\t<ul>\r\n\t\t<li>GPG can use customized directories instead of the standard ~\/.gnupg or %APPDATA%\\gnupg directories:\r\n\t\t<ul>\r\n\t\t\t<li>Environment variable GNUPGHOME can define the location.<\/li>\r\n\t\t\t<li>On Windows, a registry key may define the location (but this is deprecated).<\/li>\r\n\t\t\t<li>Portable installations may use a directory defined via a file &quot;gpgconf.ctl&quot;.<\/li>\r\n\t\t\t<li>&nbsp;GPG programs may take a --homedir command-line argument, which overrides anything.<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>Implement handling of environment variable GNUPGHOME. The other ways of GPG to get its home directory are outside the reach of JGit. Provide a&nbsp;system property &quot;jgit.gpg.home&quot; that the user can set in such cases.<\/li>\r\n\t\t<li>Do tilde replacement for the system property and for GNUPGHOME.<\/li>\r\n\t\t<li>Note that on VMS, the default directory would be ~\/gnupg (without dot). This is not accounted for, but a user on VMS could now use either the&nbsp;system property or GNUPGHOME to direct JGit to the right directory.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/446355\">446355<\/a> Support commit.template config property<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/574635\">574635<\/a> [sshd] Distinguish key type and signature algorithm for host key<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/574636\">574636<\/a> [sshd] Implement SSH config KexAlgorithms\r\n\t<ul>\r\n\t\t<li>Make the used KEX algorithms configurable via the ssh config.<\/li>\r\n\t\t<li>Also implement adding algorithms not in the default set: since sshd 2.6.0&nbsp;deprecated SHA1-based algorithms, it is possible that the default set has not all available algorithms, so adding algorithms makes sense. This enables users who have to use a git server that only supports&nbsp;old SHA1-based key exchange methods to enable those methods in the ssh config:&nbsp;<br \/>\r\n\t\t&quot;KexAlgorithms +diffie-hellman-group1-sha1&quot;<\/li>\r\n\t\t<li>There are two more SHA1 algorithms that are not enabled by default: diffie-hellman-group14-sha1 and diffie-hellman-group-exchange-sha1.<\/li>\r\n\t\t<li>KeyAlgorithms accepts a comma-separated list of algorithm names.<\/li>\r\n\t\t<li>[sshd] Log the full KEX negotiation result to help debugging KEX problems.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Teach independent negotiation (no pack file) using an option &quot;wait-for-done&quot;\r\n\t<ul>\r\n\t\t<li>From Git commit 9c1e657a8f:\r\n\t\t<ul>\r\n\t\t\t<li>Currently, the packfile negotiation step within a Git fetch cannot be done independent of sending the packfile, even though there is at&nbsp;least one application wherein this is useful - push negotiation. Therefore, make it possible for this negotiation step to be done&nbsp;independently.<\/li>\r\n\t\t\t<li>This feature is for protocol v2 only.<\/li>\r\n\t\t\t<li>In the protocol, the main hindrance towards independent negotiation is that the server can unilaterally decide to send the packfile. This is&nbsp;solved by a &quot;wait-for-done&quot; argument: the server will then wait for&nbsp;the client to say &quot;done&quot;. In practice, the client will never say it;&nbsp;instead it will cease requests once it is satisfied.<\/li>\r\n\t\t\t<li>Advertising the server capability option &quot;wait-for-done&quot; is behind the transport config: &quot;uploadpack.advertisewaitfordone&quot;, which by default is&nbsp;false.<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>UploadPack searchForReuse might impact performance in large repositories. The search for reuse phase for all the objects scans all the packfiles, looking for the best candidate to serve back to the&nbsp;client. This can lead to an expensive operation when the number of packfiles and objects is high.&nbsp;Add option&nbsp;&quot;pack.searchForReuseTimeout&quot; to limit the time spent on this search.<\/li>\r\n\t<li>BatchRefUpdate: Skip saving conflicting ref names and prefixes in memory improving the BatchRefUpdate performance from O(n^2) to O(1).<\/li>\r\n\t<li>Optimize RefDirectory.isNameConflicting() improving the name conflicting check from O(n^2) to O(1).<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/eclip.se\/575367\">575367<\/a> Ignore IllegalStateException if JVM is already shutting down<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/575385\">575385<\/a> Ensure FS#searchPath only selects executable files<\/li>\r\n\t<li>Fix RevWalk#getMergedInto&#39;s result which was wrong on the second call<\/li>\r\n\t<li>[sshd] Ignore revoked keys in OpenSshServerKeyDatabase.lookup()<\/li>\r\n\t<li>[pgm] Fix default meta variable defined in StopOptionHandler<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/573791\">573791<\/a> Retry loose object read upon &quot;Stale file handle&quot; exception<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/574178\">574178<\/a> Fix garbage collection failing to delete pack file<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/574253\">574253<\/a> Fix PathSuffixFilter: can decide only on full paths<\/li>\r\n\t<li>Fixing visibility for HostEntry constructors.<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<p>Update dependencies:<\/p>\r\n\r\n<ul>\r\n\t<li>orbit to R20210825222808 for 2021-09<\/li>\r\n\t<li>assertj to 3.20.2.v20210706-1104<\/li>\r\n\t<li>&nbsp;com.google.gson to 2.8.7.v20210624-1215<\/li>\r\n\t<li>hamcrest to 2.2.0.v20210711-0821, junit 4.13 requires hamcrest-core and hamcrest-library 1.3 therefore keep them in the target platform<\/li>\r\n\t<li>javaewah to 1.1.12.v20210622-2206<\/li>\r\n\t<li>jetty to 9.4.43.v20210629<\/li>\r\n\t<li>JMH used in benchmarks to 1.32<\/li>\r\n\t<li>org.apache.commons.compress to 1.20.0.v20210713-19<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/574220\">574220<\/a> org.apache.sshd.osgi to 2.7.0.v20210623-0618<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/574220\">574220<\/a> org.apache.sshd.sftp to 2.7.0.v20210623-0618<\/li>\r\n\t<li>org.bouncycastle.bcpg to 1.69.0.v20210713-1924<\/li>\r\n\t<li>org.bouncycastle.bcpkix to 1.69.0.v20210713-1924<\/li>\r\n\t<li>org.bouncycastle.bcprov to 1.69.0.v20210713-1924<\/li>\r\n\t<li>org.bouncycastle.bcutil 1.69.0.v20210713-1924<\/li>\r\n\t<li>org.tukaani.xz to 1.9.0.v20210624-1259<\/li>\r\n\t<li>Relax version range for hamcrest and assertj<\/li>\r\n<\/ul>\r\n\r\n<p>Update maven plugins:<\/p>\r\n\r\n<ul>\r\n\t<li>jacoco-maven-plugin to 0.8.7<\/li>\r\n\t<li>maven-dependency-plugin to 3.2.0<\/li>\r\n\t<li>maven-jxr-plugin to 3.1.1<\/li>\r\n\t<li>spotbugs-maven-plugin to 4.3.0<\/li>\r\n<\/ul>\r\n\r\n<p>Miscellaneous<\/p>\r\n\r\n<ul>\r\n\t<li>[test] Create keystore with the keytool of the running JDK<\/li>\r\n\t<li>Add 4.21 target platform<\/li>\r\n\t<li>Update 4.20 target platform to use final 4.20 release<\/li>\r\n\t<li>Remove use of deprecated getAllRefs() in ReceivePack<\/li>\r\n\t<li>[releng] japicmp: update last release version to 5.12.0.202106070339-r.<\/li>\r\n\t<li>Update bazlets to react on Maven central no longer supporting http protocol but only https<\/li>\r\n\t<li>Update bazel version to 2.0<\/li>\r\n\t<li>bazel: don&#39;t expose jsch and jzlib to org.eclipse.jgit<\/li>\r\n<\/ul>\r\n\r\n<h2>Documentation<\/h2>\r\n\r\n<ul>\r\n\t<li>CONTRIBUTING: add explicit link to ECA<\/li>\r\n\t<li>CONTRIBUTING: Use standard markdown format<\/li>\r\n\t<li>Add Eclipse code of conduct and security policy<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.13"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.13.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.13.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-06-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>Allow to skip detecting content renames for binary files<\/li>\n<li>RepoCommand: Retry commit on LockFailure<\/li>\n<li><a href=\"https:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: support binary patches<\/li>\n<li><a href=\"http:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: add a stream to apply a delta patch<\/li>\n<li><a href=\"http:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: add streams to read\/write binary patch hunks<\/li>\n<li><a href=\"http:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: add a base-85 codec<\/li>\n<li>Add git config for conflict style merge\/diff3<\/li>\n<li><a href=\"http:\/\/eclip.se\/501111\">501111<\/a> Implement ours and theirs content conflict resolution strategies<\/li>\n<li>Allow file mode conflicts in virtual base commit on recursive merge.<\/li>\n<li>Allow info messages in UsernamePasswordCredentialsProvider<\/li>\n<li><a href=\"http:\/\/eclip.se\/572103\">572103<\/a> ssh config: do environment variable replacement<\/li>\n<li><a href=\"http:\/\/eclip.se\/572056\">572056<\/a> sshd: implement server-sig-algs SSH extension (client side)<\/li>\n<li>Introduce getMergedInto(RevCommit commit, Collection&lt;Ref&gt; refs)<\/li>\n<li><a href=\"http:\/\/eclip.se\/571798\">571798<\/a> HTTP cookies: do tilde expansion on http.cookieFile<\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li>Optimize RevWalkUtils.findBranchesReachableFrom()<\/li>\n<li>Skip detecting content renames for large files<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"http:\/\/eclip.se\/573328\">573328<\/a> LockFile: create OutputStream only when needed<\/li>\n<li>RepoCommand: Do not set 'branch' if the revision is a tag<\/li>\n<li>pgm: rewrite parents when --parents flag is passed<\/li>\n<li>ApplyCommand: fix \"no newline at end\" detection<\/li>\n<li>ApplyCommand: handle completely empty context lines in text patches<\/li>\n<li>ApplyCommand: use byte arrays for text patches, not strings<\/li>\n<li><a href=\"http:\/\/eclip.se\/571585\">571585<\/a> ApplyCommand: convert to git internal format before applying patch<\/li>\n<li>SSH config: fix whitespace handling<\/li>\n<li>SSH config: fix negated patterns<\/li>\n<li>572849 ssh: ensure list is modifiable before using Iterator.remove().<\/li>\n<li>559548 sshd: don't lock the known_hosts files on reading<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Update Orbit to R20210602031627<\/li>\n<li>Upgrade eclipse-jarsigner-plugin to 1.3.1<\/li>\n<li>Upgrade maven-javadoc-plugin to 3.3.0<\/li>\n<li>Update maven-project-info-reports-plugin to 3.1.2<\/li>\n<li>Update spotbugs-maven-plugin to 4.2.3<\/li>\n<li>Update jetty to 9.4.41.v20210516<\/li>\n<li>Upgrade ecj to 3.25.0<\/li>\n<li>Upgrade wagon-ssh to 3.4.3<\/li>\n<li>Update spring-boot-maven-plugin to 2.4.4<\/li>\n<li>Update spotbugs-maven-plugin to 4.2.2<\/li>\n<li>Update japicmp-maven-plugin to 0.15.3<\/li>\n<li>Document http options supported by JGit<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>Allow to skip detecting content renames for binary files<\/li>\r\n\t<li>RepoCommand: Retry commit on LockFailure<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: support binary patches<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: add a stream to apply a delta patch<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: add streams to read\/write binary patch hunks<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/371725\">371725<\/a> ApplyCommand: add a base-85 codec<\/li>\r\n\t<li>Add git config for conflict style merge\/diff3<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/501111\">501111<\/a> Implement ours and theirs content conflict resolution strategies<\/li>\r\n\t<li>Allow file mode conflicts in virtual base commit on recursive merge.<\/li>\r\n\t<li>Allow info messages in UsernamePasswordCredentialsProvider<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/572103\">572103<\/a> ssh config: do environment variable replacement<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/572056\">572056<\/a> sshd: implement server-sig-algs SSH extension (client side)<\/li>\r\n\t<li>Introduce getMergedInto(RevCommit commit, Collection&lt;Ref&gt; refs)<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/571798\">571798<\/a> HTTP cookies: do tilde expansion on http.cookieFile<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Optimize RevWalkUtils.findBranchesReachableFrom()<\/li>\r\n\t<li>Skip detecting content renames for large files<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/eclip.se\/573328\">573328<\/a> LockFile: create OutputStream only when needed<\/li>\r\n\t<li>RepoCommand: Do not set &#39;branch&#39; if the revision is a tag<\/li>\r\n\t<li>pgm: rewrite parents when --parents flag is passed<\/li>\r\n\t<li>ApplyCommand: fix &quot;no newline at end&quot; detection<\/li>\r\n\t<li>ApplyCommand: handle completely empty context lines in text patches<\/li>\r\n\t<li>ApplyCommand: use byte arrays for text patches, not strings<\/li>\r\n\t<li><a href=\"http:\/\/eclip.se\/571585\">571585<\/a> ApplyCommand: convert to git internal format before applying patch<\/li>\r\n\t<li>SSH config: fix whitespace handling<\/li>\r\n\t<li>SSH config: fix negated patterns<\/li>\r\n\t<li>572849 ssh: ensure list is modifiable before using Iterator.remove().<\/li>\r\n\t<li>559548 sshd: don&#39;t lock the known_hosts files on reading<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Update Orbit to R20210602031627<\/li>\r\n\t<li>Upgrade eclipse-jarsigner-plugin to 1.3.1<\/li>\r\n\t<li>Upgrade maven-javadoc-plugin to 3.3.0<\/li>\r\n\t<li>Update maven-project-info-reports-plugin to 3.1.2<\/li>\r\n\t<li>Update spotbugs-maven-plugin to 4.2.3<\/li>\r\n\t<li>Update jetty to 9.4.41.v20210516<\/li>\r\n\t<li>Upgrade ecj to 3.25.0<\/li>\r\n\t<li>Upgrade wagon-ssh to 3.4.3<\/li>\r\n\t<li>Update spring-boot-maven-plugin to 2.4.4<\/li>\r\n\t<li>Update spotbugs-maven-plugin to 4.2.2<\/li>\r\n\t<li>Update japicmp-maven-plugin to 0.15.3<\/li>\r\n\t<li>Document http options supported by JGit<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.12"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-06-16 00:00:00"}],"links":[{"attributes":[],"title":"GitLab tracking issue","url":"https:\/\/gitlab.eclipse.org\/eclipsefdn\/emo-team\/emo\/-\/issues\/58"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.12.0"}],"state":[{"value":"success"}],"title":"5.12.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.12.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.12.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.12.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-06-04 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Performance Improvements<\/h2>\n<ul><li>BatchRefUpdate: Skip saving conflicting ref names and prefixes in memory. This change improves the complexity of creating n refs using BatchRefUpdate <a href=\"https:\/\/git.eclipse.org\/r\/c\/jgit\/jgit\/+\/180697\">from O(n) to O(1)<\/a>.<\/li>\n<li>Optimize RefDirectory.isNameConflicting(). This change improves complexity of creating one ref when n loose refs are present from <a href=\"https:\/\/git.eclipse.org\/r\/c\/jgit\/jgit\/+\/180559\">O(n) to O(1)<\/a>.<\/li>\n<\/ul>","summary":"","value":"<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>BatchRefUpdate: Skip saving conflicting ref names and prefixes in memory. This change improves the&nbsp;complexity of creating n refs using&nbsp;BatchRefUpdate&nbsp;<a href=\"https:\/\/git.eclipse.org\/r\/c\/jgit\/jgit\/+\/180697\">from O(n) to O(1)<\/a>.<\/li>\r\n\t<li>Optimize RefDirectory.isNameConflicting(). This change improves complexity of creating&nbsp;one ref when n loose refs are present from <a href=\"https:\/\/git.eclipse.org\/r\/c\/jgit\/jgit\/+\/180559\">O(n) to O(1)<\/a>.<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.16","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.16","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-05-13 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=573328\">573328<\/a> LockFile: create OutputStream only when needed<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=566934\">566934<\/a> Ensure post-commit hook is called after index lock was released<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=572056\">572056<\/a> sshd: try all configured signature algorithms for a key<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=572056\">572056<\/a> sshd: implement ssh config PubkeyAcceptedAlgorithms<\/li>\n<li>sshd: modernize ssh config file parsing<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Update Orbit to R20210223232630<\/li>\n<li>Remove ReftableNumbersNotIncreasingException<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=573328\">573328<\/a> LockFile: create OutputStream only when needed<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=566934\">566934<\/a> Ensure post-commit hook is called after index lock was released<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=572056\">572056<\/a> sshd: try all configured signature algorithms for a key<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=572056\">572056<\/a> sshd: implement ssh config PubkeyAcceptedAlgorithms<\/li>\r\n\t<li>sshd: modernize ssh config file parsing<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Update Orbit to R20210223232630<\/li>\r\n\t<li>Remove ReftableNumbersNotIncreasingException<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.11.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.11.1","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-03-17 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<h3>Protocols<\/h3>\n<ul><li><a href=\"https:\/\/www.eclip.se\/553083\">553083<\/a> Client-side protocol V2 support for fetching<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/563145\">563145<\/a> Enable git wire protocol version 2 on server side per default<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/541327\">541327<\/a> TransportHttp: support preemptive Basic authentication<\/li>\n<li>TransportHttp: make the connection factory configurable<\/li>\n<li>Migrate to Apache MINA sshd 2.6.0. Re-enable DSA, DSA_CERT, and RSA_CERT public key authentication.<\/li>\n<li>[pgm] Use Apache sshd by default<\/li>\n<\/ul><h3>GPG signing<\/h3>\n<ul><li><a href=\"https:\/\/www.eclip.se\/386908\">386908<\/a> TagCommand: support signing annotated tags<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/386908\">386908<\/a> Enable GpgSigner to also sign tags<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/570501\">570501<\/a> GPG: handle extended private key format<\/li>\n<li>[GPG] Provide a factory for the BouncyCastleGpgSigner<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/547536\">547536<\/a> GPG: compute the keygrip to find a secret key<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/547751\">547751<\/a> GPG signature verification via BouncyCastle<\/li>\n<li>GPG: support git config gpg.program<\/li>\n<\/ul><h3>Miscellaneous<\/h3>\n<ul><li><a href=\"https:\/\/www.eclip.se\/564794\">564794<\/a> init: allow specifying the initial branch name for the new repository<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/564794\">564794<\/a> init: add config option to set default for the initial branch name<\/li>\n<li>Restore preserved packs during missing object seeks in conjunction with --preserve-old-packs GC option<\/li>\n<li>Create a PackFile class for Pack filenames<\/li>\n<li>Rename PackFile to Pack<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/571143\">571143<\/a> IgnoreNode: include path to file for invalid .gitignore patterns<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/571143\">571143<\/a> FastIgnoreRule: include bad pattern in log message<\/li>\n<li>Allow to define additional Hook classes outside JGit<\/li>\n<li>Allow dir\/file conflicts in virtual base commit on recursive merge.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/570744\">570744<\/a> LFS: make pointer parsing more robust<\/li>\n<li>[pgm] add option --timeout to clone command<\/li>\n<li>Add the \"compression-level\" option to all ArchiveCommand formats<\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li>Improved method getting all refs except specific refs with seek on Reftable. Improvement of a factor of 15-20x for large Gerrit repositories!<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/571574\">571574<\/a> HTTP: cookie file stores expiration in seconds<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/570758\">570758<\/a> LFS: handle invalid pointers better<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/546580\">546580<\/a> Fail clone if initial branch doesn't exist in remote repository<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/570501\">570501<\/a> GPG: fix reading unprotected old-format secret keys<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/565874\">565874<\/a> dfs: handle short copies<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/553428\">553428<\/a> Post commit hook failure should not cause commit failure<\/li>\n<li>GitHook: use default charset for output and error streams<\/li>\n<li>Fix DateRevQueue tie breaks with more than 2 elements<\/li>\n<li>Fix FileRepository#convertToReftable which failed if no reflog existed<\/li>\n<li>IO: fix IO.readFully(InputStream, byte[], int) with non-zero offset<\/li>\n<li>reftable: add random suffix to table names<\/li>\n<li>TemporaryBuffer: fix toByteArray(limit)<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/535850\">535850<\/a> TransportHttp: shared SSLContext during fetch or push by introducing GitSession<\/li>\n<li>Tag message must not include the signature<\/li>\n<li>Protocol V2: don't log spurious ACKs in UploadPack<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/553083\">553083<\/a> Protocol V2: respect MAX_HAVES only once we got at least one ACK<\/li>\n<li>[spotbugs]: Fix potential NPE in FileSnapshot constructor<\/li>\n<li>FileSnapshot: don't try to read file attributes twice<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/569962\">569962<\/a> Fix NPE in DirCacheCheckout<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/547789\">547789<\/a> GPG user ID matching: use case-insensitive matching<\/li>\n<li>TagCommand: make -f work with lightweight tags for NO_CHANGE<\/li>\n<li>Added check for null on DirCacheEntry in checkoutEntry method<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Add target platform for eclipse 4.19 staging<\/li>\n<li>Bump bazel version to 4.0.0<\/li>\n<li>Require latest Maven version 3.6.3<\/li>\n<li>Update jetty to 9.4.36.v20210114<\/li>\n<li>Update com.google.gson to 2.8.6<\/li>\n<li>Update spotbugs-maven-plugin to 4.2.0<\/li>\n<li>Update eclipse-jarsigner-plugin to 1.1.7<\/li>\n<li>Update build-helper-maven-plugin to 3.2.0<\/li>\n<li>Update maven-enforcer-plugin to 3.0.0-M3<\/li>\n<li>Update maven-shade-plugin to 3.2.4<\/li>\n<li>Update spring-boot-maven-plugin to 2.4.1<\/li>\n<li>Update maven-surefire plugins to 3.0.0-M5<\/li>\n<li>Update japicmp-maven-plugin to 0.14.4<\/li>\n<li>Update spotbugs-maven-plugin to 4.1.4<\/li>\n<li>Upgrade ecj to 3.24.0<\/li>\n<li>Upgrade wagon-ssh to 3.4.2<\/li>\n<li>Update maven-site-plugin to 3.9.1<\/li>\n<li>Fix stamping to produce stable file timestamps<\/li>\n<li>Fix errorprone configuration for maven-compiler-plugin with javac<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/570451\">570451<\/a> Correct the minimum required version of Apache httpclient<\/li>\n<li>pgm: add missing dependency to org.apache.commons.logging<\/li>\n<li>Remove reftree and ketch. This was experimental code and never used in production.<\/li>\n<li>Split out loose object handling from ObjectDirectory<\/li>\n<li>Split out packfile handling from ObjectDirectory<\/li>\n<li>TagCommand: propagate NO_CHANGE information<\/li>\n<li>Move reachability checker generation into the ObjectReader object<\/li>\n<li>Fix SeparateClassloaderTestRunner on Java 9 or higher<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<h3>Protocols<\/h3>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553083\">553083<\/a> Client-side protocol V2 support for fetching<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563145\">563145<\/a> Enable git wire protocol version 2 on server side per default<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/541327\">541327<\/a> TransportHttp: support preemptive Basic authentication<\/li>\r\n\t<li>TransportHttp: make the connection factory configurable<\/li>\r\n\t<li>Migrate to Apache MINA sshd 2.6.0. Re-enable DSA, DSA_CERT, and RSA_CERT public key authentication.<\/li>\r\n\t<li>[pgm] Use Apache sshd by default<\/li>\r\n<\/ul>\r\n\r\n<h3>GPG signing<\/h3>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/386908\">386908<\/a> TagCommand: support signing annotated tags<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/386908\">386908<\/a> Enable GpgSigner to also sign tags<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/570501\">570501<\/a> GPG: handle extended private key format<\/li>\r\n\t<li>[GPG] Provide a factory for the BouncyCastleGpgSigner<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/547536\">547536<\/a> GPG: compute the keygrip to find a secret key<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/547751\">547751<\/a> GPG signature verification via BouncyCastle<\/li>\r\n\t<li>GPG: support git config gpg.program<\/li>\r\n<\/ul>\r\n\r\n<h3>Miscellaneous<\/h3>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/564794\">564794<\/a> init: allow specifying the initial branch name for the new repository<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/564794\">564794<\/a> init: add config option to set default for the initial branch name<\/li>\r\n\t<li>Restore preserved packs during missing object seeks in conjunction with --preserve-old-packs GC option<\/li>\r\n\t<li>Create a PackFile class for Pack filenames<\/li>\r\n\t<li>Rename PackFile to Pack<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/571143\">571143<\/a> IgnoreNode: include path to file for invalid .gitignore patterns<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/571143\">571143<\/a> FastIgnoreRule: include bad pattern in log message<\/li>\r\n\t<li>Allow to define additional Hook classes outside JGit<\/li>\r\n\t<li>Allow dir\/file conflicts in virtual base commit on recursive merge.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/570744\">570744<\/a> LFS: make pointer parsing more robust<\/li>\r\n\t<li>[pgm] add option --timeout to clone command<\/li>\r\n\t<li>Add the &quot;compression-level&quot; option to all ArchiveCommand formats<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Improved method getting all refs except specific refs with seek on Reftable. Improvement of a factor of 15-20x for large Gerrit repositories!<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/571574\">571574<\/a> HTTP: cookie file stores expiration in seconds<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/570758\">570758<\/a> LFS: handle invalid pointers better<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/546580\">546580<\/a> Fail clone if initial branch doesn&#39;t exist in remote repository<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/570501\">570501<\/a> GPG: fix reading unprotected old-format secret keys<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/565874\">565874<\/a> dfs: handle short copies<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553428\">553428<\/a> Post commit hook failure should not cause commit failure<\/li>\r\n\t<li>GitHook: use default charset for output and error streams<\/li>\r\n\t<li>Fix DateRevQueue tie breaks with more than 2 elements<\/li>\r\n\t<li>Fix FileRepository#convertToReftable which failed if no reflog existed<\/li>\r\n\t<li>IO: fix IO.readFully(InputStream, byte[], int) with non-zero offset<\/li>\r\n\t<li>reftable: add random suffix to table names<\/li>\r\n\t<li>TemporaryBuffer: fix toByteArray(limit)<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/535850\">535850<\/a> TransportHttp: shared SSLContext during fetch or push by introducing GitSession<\/li>\r\n\t<li>Tag message must not include the signature<\/li>\r\n\t<li>Protocol V2: don&#39;t log spurious ACKs in UploadPack<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553083\">553083<\/a> Protocol V2: respect MAX_HAVES only once we got at least one ACK<\/li>\r\n\t<li>[spotbugs]: Fix potential NPE in FileSnapshot constructor<\/li>\r\n\t<li>FileSnapshot: don&#39;t try to read file attributes twice<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/569962\">569962<\/a> Fix NPE in DirCacheCheckout<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/547789\">547789<\/a> GPG user ID matching: use case-insensitive matching<\/li>\r\n\t<li>TagCommand: make -f work with lightweight tags for NO_CHANGE<\/li>\r\n\t<li>Added check for null on DirCacheEntry in checkoutEntry method<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Add target platform for eclipse 4.19 staging<\/li>\r\n\t<li>Bump bazel version to 4.0.0<\/li>\r\n\t<li>Require latest Maven version 3.6.3<\/li>\r\n\t<li>Update jetty to 9.4.36.v20210114<\/li>\r\n\t<li>Update com.google.gson to 2.8.6<\/li>\r\n\t<li>Update spotbugs-maven-plugin to 4.2.0<\/li>\r\n\t<li>Update eclipse-jarsigner-plugin to 1.1.7<\/li>\r\n\t<li>Update build-helper-maven-plugin to 3.2.0<\/li>\r\n\t<li>Update maven-enforcer-plugin to 3.0.0-M3<\/li>\r\n\t<li>Update maven-shade-plugin to 3.2.4<\/li>\r\n\t<li>Update spring-boot-maven-plugin to 2.4.1<\/li>\r\n\t<li>Update maven-surefire plugins to 3.0.0-M5<\/li>\r\n\t<li>Update japicmp-maven-plugin to 0.14.4<\/li>\r\n\t<li>Update spotbugs-maven-plugin to 4.1.4<\/li>\r\n\t<li>Upgrade ecj to 3.24.0<\/li>\r\n\t<li>Upgrade wagon-ssh to 3.4.2<\/li>\r\n\t<li>Update maven-site-plugin to 3.9.1<\/li>\r\n\t<li>Fix stamping to produce stable file timestamps<\/li>\r\n\t<li>Fix errorprone configuration for maven-compiler-plugin with javac<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/570451\">570451<\/a> Correct the minimum required version of Apache httpclient<\/li>\r\n\t<li>pgm: add missing dependency to org.apache.commons.logging<\/li>\r\n\t<li>Remove reftree and ketch. This was experimental code and never used in production.<\/li>\r\n\t<li>Split out loose object handling from ObjectDirectory<\/li>\r\n\t<li>Split out packfile handling from ObjectDirectory<\/li>\r\n\t<li>TagCommand: propagate NO_CHANGE information<\/li>\r\n\t<li>Move reachability checker generation into the ObjectReader object<\/li>\r\n\t<li>Fix SeparateClassloaderTestRunner on Java 9 or higher<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.11"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.11.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.11.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-12-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>Add constants for parsing git wire protocol version<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/514052\">514052<\/a> Add support for reading symrefs from pack capabilities<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/568038\">568038<\/a> Allow to resolve a conflict by checking out a file<\/li>\n<li>Implement git describe --all<\/li>\n<li>Override config http.userAgent from environment GIT_HTTP_USER_AGENT<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/541500\">541500<\/a> Support \"http.userAgent\" and \"http.extraHeader\" from the git config<\/li>\n<li>sshd: support the ProxyJump ssh config. This is useful to access git repositories behind a bastion server (jump host).<\/li>\n<\/ul><h2>Monitoring &amp; Logging<\/h2>\n<ul><li>Add new performance logging to register events of type duration. The proposed logging is similar to the <a href=\"https:\/\/gerrit-review.googlesource.com\/c\/gerrit\/+\/225628\">performance logging in Gerrit<\/a>: a global Singleton is collecting the performance logs in a thread-safe events list, and at the end of the monitored command the list of events is retrieved and written to a log, after which it is cleared.<\/li>\n<li>Measure time taken for reachability checks<\/li>\n<li>Measure time taken for negotiation in protocol V2<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/567309\">567309<\/a> Add TypedConfigGetter.getPath(). This enables EGit to override with a lenient variant that logs the problem and continues with the default value.<\/li>\n<li>ReceivePackStats: Add size and count of unnecessary pushed objects<\/li>\n<li>GC#deleteOrphans: log warning for deleted orphaned files<\/li>\n<\/ul><h2>Bug fixes<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/569349\">569349<\/a> Fix PackInvalidException when fetch and repack run concurrently<\/li>\n<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=13544\">Gerrit 13544<\/a> Ensure that GC#deleteOrphans respects pack lock<\/li>\n<li>GC#deleteOrphans: handle failure to list files in pack directory<\/li>\n<li>Ensure GC.deleteOrphans() can delete read-only orphaned files on Windows<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/568950\">568950<\/a> PacketLineIn: ensure that END != DELIM<\/li>\n<li>Fix NPE in PerformanceLogContext<\/li>\n<li>Fix IOException occurring during gc<\/li>\n<li>Close Repository to fix tests failing on Windows<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/565776\">565776<\/a> Ensure .gitmodules is loaded when accessing submodule name<\/li>\n<li>sshd: better error report when user cancels authentication<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/566799\">566799<\/a> IndexDiffFilter: handle path prefixes correctly<\/li>\n<\/ul><h2>Documentation<\/h2>\n<ul><li>Document options in core section supported by JGit<\/li>\n<\/ul><h2>Build &amp; Release Engineering<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/514326\">514326<\/a>, <a href=\"https:\/\/www.eclip.se\/566475\">566475<\/a> Don't install 3rd party dependency bundles via features. Instead provide them only in the p2 repository.<\/li>\n<li>Upgrade maven-pmd-plugin to 3.14.0<\/li>\n<li>Update Orbit to R20201130205003 for 2020-12<\/li>\n<li>Ignore missing javadoc tags in test bundles<\/li>\n<li>Bazel: Allow to build and run the tests with JDK 15<\/li>\n<li>Update slf4j to 1.7.30<\/li>\n<li>Upgrade spotbugs-maven-plugin to 4.1.3<\/li>\n<li>Fix OperatorPrecedence warning flagged by error prone<\/li>\n<li>UploadPackTest#testUploadRedundantBytes: ensure test repo is closed<\/li>\n<li>Upgrade ecj to 3.23.0<\/li>\n<li>Upgrade jacoco-maven-plugin to 0.8.6<\/li>\n<li>Upgrade maven-project-info-reports-plugin to 3.1.1<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>Add constants for parsing git wire protocol version<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/514052\">514052<\/a> Add support for reading symrefs from pack capabilities<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/568038\">568038<\/a> Allow to resolve a conflict by checking out a file<\/li>\r\n\t<li>Implement git describe --all<\/li>\r\n\t<li>Override config http.userAgent from environment GIT_HTTP_USER_AGENT<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/541500\">541500<\/a> Support &quot;http.userAgent&quot; and &quot;http.extraHeader&quot; from the git config<\/li>\r\n\t<li>sshd: support the ProxyJump ssh config. This is useful to access git repositories behind a bastion server (jump host).<\/li>\r\n<\/ul>\r\n\r\n<h2>Monitoring &amp; Logging<\/h2>\r\n\r\n<ul>\r\n\t<li>Add new performance logging to register events of type duration. The proposed logging is similar to the <a href=\"https:\/\/gerrit-review.googlesource.com\/c\/gerrit\/+\/225628\">performance logging&nbsp;in Gerrit<\/a>:&nbsp;a global Singleton is collecting the performance logs in a thread-safe events list, and at the end of the monitored command the list of events is&nbsp;retrieved and written to a log, after which it is cleared.<\/li>\r\n\t<li>Measure time taken for reachability checks<\/li>\r\n\t<li>Measure time taken for negotiation in protocol V2<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/567309\">567309<\/a> Add TypedConfigGetter.getPath(). This enables EGit to override with a lenient variant that logs the&nbsp;problem and continues with the default value.<\/li>\r\n\t<li>ReceivePackStats: Add size and count of unnecessary pushed objects<\/li>\r\n\t<li>GC#deleteOrphans: log warning for deleted orphaned files<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/569349\">569349<\/a> Fix PackInvalidException when fetch and repack run concurrently<\/li>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=13544\">Gerrit 13544<\/a>&nbsp;Ensure that GC#deleteOrphans respects pack lock<\/li>\r\n\t<li>GC#deleteOrphans: handle failure to list files in pack directory<\/li>\r\n\t<li>Ensure GC.deleteOrphans() can delete read-only orphaned files on Windows<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/568950\">568950<\/a> PacketLineIn: ensure that END != DELIM<\/li>\r\n\t<li>Fix NPE in PerformanceLogContext<\/li>\r\n\t<li>Fix IOException occurring during gc<\/li>\r\n\t<li>Close Repository to fix tests failing on Windows<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/565776\">565776<\/a> Ensure .gitmodules is loaded when accessing submodule name<\/li>\r\n\t<li>sshd: better error report when user cancels authentication<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/566799\">566799<\/a> IndexDiffFilter: handle path prefixes correctly<\/li>\r\n<\/ul>\r\n\r\n<h2>Documentation<\/h2>\r\n\r\n<ul>\r\n\t<li>Document options in core section supported by JGit<\/li>\r\n<\/ul>\r\n\r\n<h2>Build &amp; Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/514326\">514326<\/a>, <a href=\"https:\/\/www.eclip.se\/566475\">566475<\/a> Don&#39;t install 3rd party dependency bundles via features. Instead provide them only in the p2 repository.<\/li>\r\n\t<li>Upgrade maven-pmd-plugin to 3.14.0<\/li>\r\n\t<li>Update Orbit to R20201130205003 for 2020-12<\/li>\r\n\t<li>Ignore missing javadoc tags in test bundles<\/li>\r\n\t<li>Bazel: Allow to build and run the tests with JDK 15<\/li>\r\n\t<li>Update slf4j to 1.7.30<\/li>\r\n\t<li>Upgrade spotbugs-maven-plugin to 4.1.3<\/li>\r\n\t<li>Fix OperatorPrecedence warning flagged by error prone<\/li>\r\n\t<li>UploadPackTest#testUploadRedundantBytes: ensure test repo is closed<\/li>\r\n\t<li>Upgrade ecj to 3.23.0<\/li>\r\n\t<li>Upgrade jacoco-maven-plugin to 0.8.6<\/li>\r\n\t<li>Upgrade maven-project-info-reports-plugin to 3.1.1<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.10.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.10.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-12-01 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=569349\" rel=\"noopener\" target=\"_blank\">569349<\/a> Fix PackInvalidException when fetch and repack run concurrently<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=569349\" rel=\"noopener\" target=\"_blank\">569349<\/a>&nbsp;Fix PackInvalidException when fetch and repack run concurrently<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.9","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.9","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-12-01 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=569349\" rel=\"noopener\" target=\"_blank\">569349<\/a> Fix PackInvalidException when fetch and repack run concurrently<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=569349\" rel=\"noopener\" target=\"_blank\">569349<\/a>&nbsp;Fix PackInvalidException when fetch and repack run concurrently<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.15","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.15","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-11-26 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p>Ensure that GC#deleteOrphans respects pack lock. If pack or index files are guarded by a pack lock (.keep file) deleteOrphans() should not touch the respective files protected by the lock file. Otherwise it may interfere with PackInserter concurrently inserting a new pack file and its index. See <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=13544\">Gerrit Issue 13544<\/a>.<\/p>\n<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>Ensure that GC#deleteOrphans respects pack lock. If pack or index files are guarded by a pack lock (.keep file) deleteOrphans() should not touch the respective files protected by the lock file. Otherwise it may interfere with PackInserter concurrently inserting a new pack file and its index. See&nbsp;<a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=13544\">Gerrit Issue&nbsp;13544<\/a>.<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.8","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.8","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-11-26 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p>Ensure that GC#deleteOrphans respects pack lock. If pack or index files are guarded by a pack lock (.keep file) deleteOrphans() should not touch the respective files protected by the lock file. Otherwise it may interfere with PackInserter concurrently inserting a new pack file and its index. See <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=13544\">Gerrit Issue 13544<\/a>.<\/p>\n<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>Ensure that GC#deleteOrphans respects pack lock. If pack or index files are guarded by a pack lock (.keep file) deleteOrphans() should not touch the respective files protected by the lock file. Otherwise it may interfere with PackInserter concurrently inserting a new pack file and its index. See <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=13544\">Gerrit Issue&nbsp;13544<\/a>.<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.14","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.14","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-09-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>Add DfsBundleWriter which writes out the entire repository to a Git bundle file. Useful for backing up a repository as-is.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/565774\">565774<\/a> DirCache: support git index V4<\/li>\n<li>Add support for tree filters when fetching<\/li>\n<\/ul><h2>Performance Improvements:<\/h2>\n<ul><li><a href=\"http:\/\/www.eclip.se\/565707\">565707<\/a> FS: use binary search to determine filesystem timestamp resolution<\/li>\n<li>Do not send empty blob in response to blob:none filter. In particular, this means we do not need to look up the size of the filtered blobs, which should speed up clones.<\/li>\n<li>PackBitmapIndex: Do not buffer inflated bitmap during bitmap creation.<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"http:\/\/www.eclip.se\/565854\">565854<\/a> SshdSession: close channel gracefully<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/564386\">564386<\/a> GPG: include signer's user ID in the signature<\/li>\n<li>ResolveMerger: do not content-merge gitlinks on del\/mod conflicts<\/li>\n<li>ResolveMerger: choose OURS on gitlink when option ignoreConflicts is used. GITLINK merging is a special case of recursive merge because of limitations of GITLINK type of entry. It can't contain more than 1 sha-1 so jgit can't write merge conflicts in place like it can with a blob.<\/li>\n<li>Fix possible NegativeArraySizeException in PackIndexV1<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/565637\">565637<\/a> Do not prematurely create directory of jgit's XDG config file<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/566170\">566170<\/a> FS: write to JGit config in a background thread<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/566170\">566170<\/a> FS: don't cache fallback for timestamp resolution if running in background<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/565048\">565048<\/a> Keep line endings for text files committed with CR\/LF on text=auto<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/563740\">563740<\/a> Delay WindowCache statistics JMX MBean registration<\/li>\n<li>Fix JSchProcess.waitFor() with time-out<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/565394\">565394<\/a> sshd: work around a race condition in Apache MINA sshd 2.4.0\/2.5.x<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/563380\">563380<\/a> sshd: store per-session data on the sshd session object<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/564372\">564372<\/a> FS_POSIX: avoid prompt to install the XCode tools on OS X<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/564202\">564202<\/a> Use LinkedBlockingQueue for executor determining filesystem attributes<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/565081\">565081<\/a> DiffFormatter: correctly deal with tracked files in ignored folders<\/li>\n<li><a href=\"http:\/\/www.eclip.se\/564428\">564428<\/a> Fix writing GPG signatures with trailing newline<\/li>\n<li>Improve error message when receive.maxCommandBytes is exceeded<\/li>\n<li>LfsConnectionFactory#getLfsUrl: Fix unconditional break in for-loop<\/li>\n<li>MergedReftable: Include the last reftable in determining minUpdateIndex<\/li>\n<\/ul><h2>Build and Release Engineering:<\/h2>\n<ul><li>Bump Bazel version to 3.5.0<\/li>\n<li>[bazel] Add missing dependency to slf4j-api<\/li>\n<li>Add jgit-4.17-staging target platform for 2020-09<\/li>\n<li>Update target platform to R20200831200620<\/li>\n<li>Update org.apache.commons.codec to 1.14.0.v20200818-1422<\/li>\n<li>Update org.apache.httpcomponents.httpclient to 4.5.10.v20200830-2311<\/li>\n<li>Update org.bouncycastle.bcpg  to 1.65.0.v20200527-1955<\/li>\n<li>Update org.bouncycastle.bcpkix to 1.65.0.v20200527-1955<\/li>\n<li>Update org.bouncycastle.bcprov to 1.65.1.v20200529-1514<\/li>\n<li>Update plexus-compiler to 2.8.7<\/li>\n<li>Update Jetty to 9.4.30.v20200611<\/li>\n<li>Upgrade maven-resources-plugin to 3.2.0<\/li>\n<li>Upgrade plexus-compiler version to 2.8.8<\/li>\n<li>Upgrade maven-site-plugin to 3.9.1<\/li>\n<li>Upgrade build-helper-maven-plugin to 3.2.0<\/li>\n<li>Upgrade spotbugs to 4.0.4<\/li>\n<li>Upgrade ecj to 3.22.0<\/li>\n<li>sshd: use PropertyResolver in test to improve the SshTestGitServer API for accessing the server properties.<\/li>\n<li>Remove dependency on JSch from SSH test framework<\/li>\n<li>Bazel: Add workspace status command to stamp final artifact and include implementation version in jgit library.<\/li>\n<li>Remove workaround for signing jars using Tycho plugins<\/li>\n<li>Use https for URL of jgit website<\/li>\n<li>Fix CI information in pom.xml<\/li>\n<li>Use gitiles as scm url in pom.xml for browsing source code<\/li>\n<li>Update API baseline to 5.8.0.202006091008-r<\/li>\n<li>Handle Fragment-Host declaration when updating version<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>Add DfsBundleWriter which writes out the entire repository to a Git bundle file. Useful for backing up a repository as-is.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/565774\">565774<\/a> DirCache: support git index V4<\/li>\r\n\t<li>Add support for tree filters when fetching<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements:<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/565707\">565707<\/a> FS: use binary search to determine filesystem timestamp resolution<\/li>\r\n\t<li>Do not send empty blob in response to blob:none filter. In particular, this means we do not need to look up the size of the&nbsp;filtered blobs, which should speed up clones.<\/li>\r\n\t<li>PackBitmapIndex: Do not buffer inflated bitmap during bitmap creation.<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/565854\">565854<\/a> SshdSession: close channel gracefully<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/564386\">564386<\/a> GPG: include signer&#39;s user ID in the signature<\/li>\r\n\t<li>ResolveMerger: do not content-merge gitlinks on del\/mod conflicts<\/li>\r\n\t<li>ResolveMerger: choose OURS on gitlink when option ignoreConflicts is used. GITLINK merging is a special case of recursive merge because of&nbsp;limitations of GITLINK type of entry. It can&#39;t contain more than 1 sha-1&nbsp;so jgit can&#39;t write merge conflicts in place like it can with a blob.<\/li>\r\n\t<li>Fix possible NegativeArraySizeException in PackIndexV1<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/565637\">565637<\/a> Do not prematurely create directory of jgit&#39;s XDG config file<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/566170\">566170<\/a> FS: write to JGit config in a background thread<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/566170\">566170<\/a> FS: don&#39;t cache fallback for timestamp resolution if running in background<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/565048\">565048<\/a> Keep line endings for text files committed with CR\/LF on text=auto<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/563740\">563740<\/a> Delay WindowCache statistics JMX MBean registration<\/li>\r\n\t<li>Fix JSchProcess.waitFor() with time-out<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/565394\">565394<\/a> sshd: work around a race condition in Apache MINA sshd 2.4.0\/2.5.x<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/563380\">563380<\/a> sshd: store per-session data on the sshd session object<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/564372\">564372<\/a> FS_POSIX: avoid prompt to install the XCode tools on OS X<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/564202\">564202<\/a> Use LinkedBlockingQueue for executor determining filesystem attributes<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/565081\">565081<\/a> DiffFormatter: correctly deal with tracked files in ignored folders<\/li>\r\n\t<li><a href=\"http:\/\/www.eclip.se\/564428\">564428<\/a> Fix writing GPG signatures with trailing newline<\/li>\r\n\t<li>Improve error message when receive.maxCommandBytes is exceeded<\/li>\r\n\t<li>LfsConnectionFactory#getLfsUrl: Fix unconditional break in for-loop<\/li>\r\n\t<li>MergedReftable: Include the last reftable in determining minUpdateIndex<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering:<\/h2>\r\n\r\n<ul>\r\n\t<li>Bump Bazel version to 3.5.0<\/li>\r\n\t<li>[bazel] Add missing dependency to slf4j-api<\/li>\r\n\t<li>Add jgit-4.17-staging target platform for 2020-09<\/li>\r\n\t<li>Update target platform to R20200831200620<\/li>\r\n\t<li>Update org.apache.commons.codec to 1.14.0.v20200818-1422<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpclient to 4.5.10.v20200830-2311<\/li>\r\n\t<li>Update org.bouncycastle.bcpg&nbsp; to 1.65.0.v20200527-1955<\/li>\r\n\t<li>Update org.bouncycastle.bcpkix to 1.65.0.v20200527-1955<\/li>\r\n\t<li>Update org.bouncycastle.bcprov to 1.65.1.v20200529-1514<\/li>\r\n\t<li>Update plexus-compiler to 2.8.7<\/li>\r\n\t<li>Update Jetty to 9.4.30.v20200611<\/li>\r\n\t<li>Upgrade maven-resources-plugin to 3.2.0<\/li>\r\n\t<li>Upgrade plexus-compiler version to 2.8.8<\/li>\r\n\t<li>Upgrade maven-site-plugin to 3.9.1<\/li>\r\n\t<li>Upgrade build-helper-maven-plugin to 3.2.0<\/li>\r\n\t<li>Upgrade spotbugs to 4.0.4<\/li>\r\n\t<li>Upgrade ecj to 3.22.0<\/li>\r\n\t<li>sshd: use PropertyResolver in test to improve the SshTestGitServer API for accessing the server properties.<\/li>\r\n\t<li>Remove dependency on JSch from SSH test framework<\/li>\r\n\t<li>Bazel: Add workspace status command to stamp final artifact and include implementation version in jgit library.<\/li>\r\n\t<li>Remove workaround for signing jars using Tycho plugins<\/li>\r\n\t<li>Use https for URL of jgit website<\/li>\r\n\t<li>Fix CI information in pom.xml<\/li>\r\n\t<li>Use gitiles as scm url in pom.xml for browsing source code<\/li>\r\n\t<li>Update API baseline to 5.8.0.202006091008-r<\/li>\r\n\t<li>Handle Fragment-Host declaration when updating version<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.9"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.9.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.9.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-07-14 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Release to ship fix for <a href=\"https:\/\/bugs.eclip.se\/501419\">#501419<\/a><\/p>\n","summary":"","value":"<p>Release to ship fix for <a href=\"https:\/\/bugs.eclip.se\/501419\">#501419<\/a><\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.8.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.8.1","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-06-17 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>Add getter for unpackErrorHandler in ReceivePack<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/437855\">437855<\/a>, <a href=\"https:\/\/www.eclip.se\/550529\">550529<\/a>: Add Git.shutdown method for releasing resources held by JGit process<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/548763\">548763<\/a> GPG: don't prompt for a passphrase for unprotected keys<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/553625\">553625<\/a> Decouple code depending on JSch ssh client from JGit Core<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/559106\">559106<\/a> Decouple code depending on BouncyCastle from JGit Core<\/li>\n<li>Builder API to configure SshdSessionFactories<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/553206\">553206<\/a> Include full IssuerFingerprint in GPG signature<\/li>\n<li>lfs server using object storage: Allow for using custom s3 host with lfs server.<br \/>\n\tThis will allow for storing lfs objects e.g. using minio or on-prem.<\/li>\n<li>revwalk: Introduce bitmap-based object reachability checker<\/li>\n<li>Enable passing java options to jgit command line executable by setting the environment variable \"java_args\", e.g. $ java_args=\"-Xmx8g\" jgit log<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/561021\">561021<\/a> Allow explicitly setting the tag option for the remote configuration when cloning a repository.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/560936\">560936<\/a> TransportHttp: support HTTP response 308 Permanent Redirect<\/li>\n<\/ul><h2>Performance<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/563740\">563740<\/a> WindowCache: conditional JMX setup<\/li>\n<li>PackBitmapIndex: Reduce memory usage in GC<\/li>\n<li>PackBitmapIndex: Add AddToBitmapWithCacheFilter which updates a client-provided {@code BitmapBuilder} as a side effect of a revwalk. It short circuits the walk when it encounters a commit which is included in the provided bitmap's BitmapIndex or if it encounters the client-provided cached commit.<\/li>\n<li>ReceivePack: Introduce IterativeConnectivityChecker which runs a connectivity check with a filtered set of references, and falls back to using the full set of advertised references. We tested it inside Google and it improves connectivity for certain topologies and can speed up push.<\/li>\n<li>ApplyCommand: use Files#copy to copy file to improve performance<\/li>\n<li>UploadPack: Use more relevant refs first in object reachability check<\/li>\n<li>UploadPack: Clear advertised ref map after negotiation when it is no longer used to reduce heap usage<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/562348\">562348<\/a> ApplyCommand: use context lines to determine hunk location<\/li>\n<li>ObjectDirectory: Explicitly handle NoSuchFileException<\/li>\n<li>ObjectDirectory: Fail immediately when atomic move is not supported<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/514326\">514326<\/a> Do not include log4j implementation in jgit<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/563739\">563739<\/a> Verify that the user home directory is valid<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/563570\">563570<\/a> RawTextComparator.WS_IGNORE_CHANGE must not compare whitespace<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/563138\">563138<\/a> TransportHttp: abort on time-out or on SocketException<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/561877\">561877<\/a> Ignore core.eol if core.autocrlf=input<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/561341\">561341<\/a> Attributes: fix handling of text=auto in combination with eol to the new interpretation of gitattributes since git 2.10<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/563022\">563022<\/a> Fix downloading LFS Object fails behind proxy<\/li>\n<li>Fix NPE occurring when calling CheckoutCommand with forced == true option when the branch isn't changed and there is deleted uncommitted file.<\/li>\n<li>When applying a patch that contains renames or copies using ApplyCommand, also apply all hunks that apply to the renamed or copied file.<\/li>\n<li>Create parent directories when renaming a file in ApplyCommand<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/560903\">560903<\/a> Fix human name for local .bundle files<\/li>\n<li>Scan through all merged reftables for max\/min update indices since reftables might have update index ranges that are overlapped.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/408846\">408846<\/a> FileUtils: improve delete (Windows) by ensuring files are writable before trying to delete them.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/561666\">561666<\/a> FS.runInShell(): handle quoted filters and hooksPath containing blanks<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/499934\">499934<\/a> Fix javadoc typo<\/li>\n<li>ReceivePack: Use error message if set in ReceiveCommand can have an error message.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/561438\">561438<\/a> Handle non-normalized index also for executable files<\/li>\n<li>ResolveMerger: Ignore merge conflicts if asked so. The recursive merge strategy builds a virtual ancestor merging recursively the common bases (when more than one) between the  want-to-merge commits. While building this virtual ancestor, content conflicts are ignored, but current code doesn't do so when a file is removed.<\/li>\n<li>RevWalk: fix bad topo flags error message<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Update Bazel version to 3.1.0<\/li>\n<li>Upgrade build-helper-maven-plugin to 3.1.0<\/li>\n<li>Upgrade ecj to 3.21.0<\/li>\n<li>Upgrade maven-antrun-plugin to 3.0.0<\/li>\n<li>Upgrade maven-dependency-plugin to 3.1.2<\/li>\n<li>Upgrade maven-javadoc-plugin to 3.2.0<\/li>\n<li>Upgrade maven-project-info-reports-plugin to 3.1.0<\/li>\n<li>Upgrade maven-shade-plugin to 3.2.4<\/li>\n<li>Upgrade maven-site-plugin to 3.9.0<\/li>\n<li>Upgrade spotbugs-maven-plugin to 4.0.0<\/li>\n<li>Upgrade Tycho to 1.7.0<\/li>\n<li>Upgrade wagon-ssh to 3.4.0<\/li>\n<\/ul><ul><li>Update Ant to 1.10.8<\/li>\n<li>Update Bouncy Castle to 1.65 (bcprov to 1.65.1)<\/li>\n<li>Update jetty to 9.4.28.v20200408<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/561078\">561078<\/a> Update org.apache.sshd to 2.4.0<\/li>\n<li>Update Orbit to R20200529191137 for final Eclipse release 2020-06<\/li>\n<li>Add 4.16 staging target platform<\/li>\n<li>Set baseline for japicmp to 5.7.0.202003110725-r<\/li>\n<\/ul><ul><li>Add benchmark for strategies how to move a file<\/li>\n<li>ObjectDirectory: clean up insertUnpackedObject and improve logging<\/li>\n<li>In-memory SSH keys for the \"no files\" sshd tests<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/563380\">563380<\/a> Log stack trace if CachingKeyPairProvider hits unexpected exception<\/li>\n<li>Always use https to access download.eclipse.org<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/562274\">562274<\/a> Bazel: Disable SecurityManagerMissingPermissionsTest test<\/li>\n<li>Document gc and pack relevant options<\/li>\n<li>Define constants for pack config option keys<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>Add getter for unpackErrorHandler in ReceivePack<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/437855\">437855<\/a>, <a href=\"https:\/\/www.eclip.se\/550529\">550529<\/a>: Add Git.shutdown method&nbsp;for releasing resources held by JGit process<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/548763\">548763<\/a> GPG: don&#39;t prompt for a passphrase for unprotected keys<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553625\">553625<\/a> Decouple code depending on JSch ssh client from JGit Core<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/559106\">559106<\/a> Decouple code depending on BouncyCastle from JGit Core<\/li>\r\n\t<li>Builder API to configure SshdSessionFactories<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553206\">553206<\/a> Include full IssuerFingerprint in GPG signature<\/li>\r\n\t<li>lfs server using object storage: Allow for using custom s3 host with lfs server.<br \/>\r\n\tThis will allow for storing lfs objects e.g. using minio or on-prem.<\/li>\r\n\t<li>revwalk: Introduce bitmap-based object reachability checker<\/li>\r\n\t<li>Enable passing java options to jgit command line executable by setting the environment variable &quot;java_args&quot;, e.g. $ java_args=&quot;-Xmx8g&quot; jgit log<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/561021\">561021<\/a> Allow explicitly setting the tag option for the remote configuration when cloning a repository.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/560936\">560936<\/a> TransportHttp: support HTTP response 308 Permanent Redirect<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563740\">563740<\/a> WindowCache: conditional JMX setup<\/li>\r\n\t<li>PackBitmapIndex: Reduce memory usage in GC<\/li>\r\n\t<li>PackBitmapIndex: Add AddToBitmapWithCacheFilter which updates a client-provided {@code BitmapBuilder} as a side effect of a revwalk.&nbsp;It short circuits the walk when it&nbsp;encounters a commit which is included in the provided bitmap&#39;s BitmapIndex or&nbsp;if it encounters the client-provided&nbsp;cached commit.<\/li>\r\n\t<li>ReceivePack: Introduce IterativeConnectivityChecker which runs a connectivity check with a filtered set of references, and falls back to using the&nbsp;full set of advertised references. We tested it inside Google and it improves connectivity for certain&nbsp;topologies and can speed up push.<\/li>\r\n\t<li>ApplyCommand: use Files#copy to copy file to improve performance<\/li>\r\n\t<li>UploadPack: Use more relevant refs first in object reachability check<\/li>\r\n\t<li>UploadPack: Clear advertised ref map after negotiation when it is no longer used to reduce heap usage<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/562348\">562348<\/a> ApplyCommand: use context lines to determine hunk location<\/li>\r\n\t<li>ObjectDirectory: Explicitly handle NoSuchFileException<\/li>\r\n\t<li>ObjectDirectory: Fail immediately when atomic move is not supported<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/514326\">514326<\/a> Do not include log4j implementation in jgit<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563739\">563739<\/a> Verify that the user home directory is valid<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563570\">563570<\/a> RawTextComparator.WS_IGNORE_CHANGE must not compare whitespace<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563138\">563138<\/a> TransportHttp: abort on time-out or on SocketException<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/561877\">561877<\/a> Ignore core.eol if core.autocrlf=input<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/561341\">561341<\/a> Attributes: fix handling of text=auto in combination with eol to the new interpretation of gitattributes since git 2.10<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563022\">563022<\/a> Fix downloading LFS Object fails behind proxy<\/li>\r\n\t<li>Fix NPE occurring when calling CheckoutCommand with forced == true option when the branch isn&#39;t changed and there is deleted uncommitted file.<\/li>\r\n\t<li>When applying a patch that contains renames or copies using ApplyCommand, also apply all hunks that apply to the renamed or copied file.<\/li>\r\n\t<li>Create parent directories when renaming a file in ApplyCommand<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/560903\">560903<\/a> Fix human name for local .bundle files<\/li>\r\n\t<li>Scan through all merged reftables for max\/min update indices since reftables might have update index ranges that are overlapped.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/408846\">408846<\/a> FileUtils: improve delete (Windows) by ensuring files are writable before trying to delete them.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/561666\">561666<\/a> FS.runInShell(): handle quoted filters and hooksPath containing blanks<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/499934\">499934<\/a> Fix javadoc typo<\/li>\r\n\t<li>ReceivePack: Use error message if set in ReceiveCommand can have an error message.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/561438\">561438<\/a> Handle non-normalized index also for executable files<\/li>\r\n\t<li>ResolveMerger: Ignore merge conflicts if asked so. The recursive merge strategy builds a virtual ancestor merging recursively the common bases (when more than one) between the&nbsp; want-to-merge commits. While building this virtual ancestor, content conflicts are ignored, but current code doesn&#39;t do so when a file is&nbsp;removed.<\/li>\r\n\t<li>RevWalk: fix bad topo flags error message<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Update Bazel version to 3.1.0<\/li>\r\n\t<li>Upgrade build-helper-maven-plugin to 3.1.0<\/li>\r\n\t<li>Upgrade ecj to 3.21.0<\/li>\r\n\t<li>Upgrade maven-antrun-plugin to 3.0.0<\/li>\r\n\t<li>Upgrade maven-dependency-plugin to 3.1.2<\/li>\r\n\t<li>Upgrade maven-javadoc-plugin to 3.2.0<\/li>\r\n\t<li>Upgrade maven-project-info-reports-plugin to 3.1.0<\/li>\r\n\t<li>Upgrade maven-shade-plugin to 3.2.4<\/li>\r\n\t<li>Upgrade maven-site-plugin to 3.9.0<\/li>\r\n\t<li>Upgrade spotbugs-maven-plugin to 4.0.0<\/li>\r\n\t<li>Upgrade Tycho to 1.7.0<\/li>\r\n\t<li>Upgrade wagon-ssh to 3.4.0<\/li>\r\n<\/ul>\r\n\r\n<ul>\r\n\t<li>Update Ant to 1.10.8<\/li>\r\n\t<li>Update Bouncy Castle to 1.65 (bcprov to 1.65.1)<\/li>\r\n\t<li>Update jetty to 9.4.28.v20200408<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/561078\">561078<\/a> Update org.apache.sshd to 2.4.0<\/li>\r\n\t<li>Update Orbit to R20200529191137 for final Eclipse release 2020-06<\/li>\r\n\t<li>Add 4.16 staging target platform<\/li>\r\n\t<li>Set baseline for japicmp to 5.7.0.202003110725-r<\/li>\r\n<\/ul>\r\n\r\n<ul>\r\n\t<li>Add benchmark for strategies how to move a file<\/li>\r\n\t<li>ObjectDirectory: clean up insertUnpackedObject and improve logging<\/li>\r\n\t<li>In-memory SSH keys for the &quot;no files&quot; sshd tests<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/563380\">563380<\/a> Log stack trace if CachingKeyPairProvider hits unexpected exception<\/li>\r\n\t<li>Always use https to access download.eclipse.org<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/562274\">562274<\/a> Bazel: Disable SecurityManagerMissingPermissionsTest test<\/li>\r\n\t<li>Document gc and pack relevant options<\/li>\r\n\t<li>Define constants for pack config option keys<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.8"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-06-17 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.8.0"}],"state":[{"value":"success"}],"title":"5.8.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.8.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.8.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.8.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-03-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>Update reftable storage repo layout. The change c217d33, \"Documentation\/technical\/reftable: improve repo layout\" defines a new repository layout, which was agreed with the git-core mailing list. It addresses the following problems:\n<ul><li>old git clients will not recognize reftable-based repositories, and look at encompassing directories.<\/li>\n<li> Poorly written tools might write directly into .git\/refs\/heads\/BRANCH.<\/li>\n<li> Since we consider JGit reftable as experimental (git-core doesn't support it yet), we have no backward compatibility. If you created a repository with reftable between mid-Nov 2019 and now, you can do the following to convert:\n<ul><li>mv .git\/refs .git\/reftable\/tables.list<br \/>\n\t\t\tgit config core.repositoryformatversion 1<br \/>\n\t\t\tgit config extensions.refStorage reftable<\/li>\n<\/ul><\/li>\n<\/ul><\/li>\n<li>Documentation\/technical\/reftable: improve repo layout. Previously, the list of tables was in .git\/refs. This makes    repo detection fail in older clients, which is undesirable. This is proposal was discussed and approved on the git@vger list at https:\/\/lore.kernel.org\/git\/CAFQ2z_PvKiz==GyS6J1H1uG0FRPL86JvDj+LjX1We4-yCSVQ+iZGxA/HNeU65s8Co@HV22S7s65yZH8nJZ. For backward compatibility, JGit could detect a file under .git\/refs and use it as a reftable list.<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/559526\">559526<\/a> Make the IMatcher public API<\/li>\n<li>ReceivePack: enable overriding filterCommands and executeCommands<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/558709\">558709<\/a> TLS support on IBM JDKs<\/li>\n<li>pgm: add option if reflogs should be written when converting to reftable<\/li>\n<li>pgm: add option to configure if convert-ref-storage should create backup<\/li>\n<li>Set config \"extensions\" option when converting ref storage format between refdirectory and reftable<\/li>\n<li>transport: enable custom error handling<\/li>\n<li>GitSmartHttpTools: Do not use sideband when sending an error but use an error packet always<\/li>\n<\/ul><h2>Performance improvements<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/560527\">560527<\/a> Expose FileStoreAttributes.setBackground()<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/560414\">560414<\/a> Revert \"Prepend hostname to subsection used to store file timestamp resolution\"<\/li>\n<li>AmazonS3: Speed up fetch, try recent packs first<\/li>\n<li>Using StringBuilder in StringUtils#capitalize method<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/558577\">558577<\/a> Cygwin expects forward slashes for commands to be run via sh.exe<\/li>\n<li>ObjectWalk: Add null check before skip tree.<\/li>\n<li>JSch ssh client: do not fail if known hosts file does not contain valid host key<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/551690\">551690<\/a> FS: Don't use innocuous threads for CompletableFuture<\/li>\n<li>Fix SshSessionFactory#setInstance to use service loader<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/553625\">553625<\/a> Use ServiceLoader to define the default SSH session factory.<\/li>\n<li>UploadPackServlet: Use uploadWithExceptionPropagation<\/li>\n<\/ul><h2>Build and release engineering<\/h2>\n<ul><li>Bump Bazel version to 2.2.0<\/li>\n<li>Update bazlets and bazel version<\/li>\n<li>Add 4.14 and 4.15-staging target platforms<\/li>\n<li>Update Orbit to R20200224183213 for 2020-03<\/li>\n<li>Remove use of org.bouncycastle.util.encoders.Hex<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/559106\">559106<\/a> Remove use of org.bouncycastle.util.io.TeeOutputStream<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/559735\">559735<\/a> Include org.apache.commons.codec 1.13 in the JGit http.apache.feature<\/li>\n<li>Upgrade plexus-compiler-{eclipse|javac|javac-errorprone} to 2.8.6<\/li>\n<li>Upgrade maven-shade-plugin to 3.2.2<\/li>\n<li>Upgrade maven-pmd-plugin to 3.13.0<\/li>\n<li>Update maven-surefire-plugin to 3.0.0-M4<\/li>\n<li>Update japicmp-maven-plugin to 0.14.3<\/li>\n<li>Update org.junit to 4.13.0.v20200126-2018<\/li>\n<li>Replace ExpectedException which was deprecated in junit 4.13<\/li>\n<li>Replace deprecated junit assertion methods with hamcrest<\/li>\n<li>Add org.assertj 3.14.0.v20200120-1926 to target platform<\/li>\n<li>Update to Tycho 1.6.0<\/li>\n<li>Update javaewah to 1.1.7.v20200107-0831<\/li>\n<li>Update org.apache.commons.codec to 1.13.0.v20200108-0001<\/li>\n<li>Update org.apache.commons.compress to 1.19.0.v20200106-2343<\/li>\n<li>Update org.apache.httpcomponents.httpclient to 4.5.10.v20200114-1512<\/li>\n<li>Update org.apache.httpcomponents.httpcore to 4.4.12.v20200108-1212<\/li>\n<li>Upgrade jetty to 9.4.25.v20191220<\/li>\n<li>Update spring-boot-maven-plugin to 2.1.5.RELEASE<\/li>\n<li>Upgrade maven-source-plugin to 3.2.1<\/li>\n<li>Upgrade ecj to 3.20.0<\/li>\n<li>Upgrade error_prone_core to 2.3.4<\/li>\n<li>ErrorProne: Enable and fix UnusedException check<\/li>\n<li>Add resource preferences for top level jgit project<\/li>\n<li>ReceivePack: Move connectivity check to separate class<\/li>\n<li>[releng] Update year in copyright notices for features<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/548298\">548298<\/a> Update EDL 1.0 license headers to new short SPDX compliant format<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>Update reftable storage repo layout. The change c217d33, &quot;Documentation\/technical\/reftable:&nbsp;improve repo layout&quot;&nbsp;defines a new repository layout, which was&nbsp;agreed with the git-core mailing list.&nbsp;It addresses the following problems:\r\n\t<ul>\r\n\t\t<li>old git clients will not recognize reftable-based repositories, and look at encompassing directories.<\/li>\r\n\t\t<li>&nbsp;Poorly written tools might write directly into&nbsp;.git\/refs\/heads\/BRANCH.<\/li>\r\n\t\t<li>&nbsp;Since we consider JGit reftable as experimental (git-core doesn&#39;t support it yet), we have no backward compatibility. If you created a&nbsp;repository with reftable between mid-Nov 2019 and now, you can do the&nbsp;following to convert:\r\n\t\t<ul>\r\n\t\t\t<li>mv .git\/refs .git\/reftable\/tables.list<br \/>\r\n\t\t\tgit config core.repositoryformatversion 1<br \/>\r\n\t\t\tgit config extensions.refStorage reftable<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Documentation\/technical\/reftable: improve repo layout. Previously, the list of tables was in .git\/refs. This makes&nbsp; &nbsp; repo detection fail in older clients, which is undesirable. This is proposal was discussed and approved on the git@vger list at&nbsp;https:\/\/lore.kernel.org\/git\/CAFQ2z_PvKiz==GyS6J1H1uG0FRPL86JvDj+LjX1We4-yCSVQ+iZGxA/HNeU65s8Co@HV22S7s65yZH8nJZ.&nbsp;For backward compatibility, JGit could detect a file under .git\/refs and&nbsp;use it as a reftable list.<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/559526\">559526<\/a> Make the IMatcher public API<\/li>\r\n\t<li>ReceivePack: enable overriding filterCommands and executeCommands<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/558709\">558709<\/a> TLS support on IBM JDKs<\/li>\r\n\t<li>pgm: add option if reflogs should be written when converting to reftable<\/li>\r\n\t<li>pgm: add option to configure if convert-ref-storage should create backup<\/li>\r\n\t<li>Set config &quot;extensions&quot; option when converting ref storage format between refdirectory and reftable<\/li>\r\n\t<li>transport: enable custom error handling<\/li>\r\n\t<li>GitSmartHttpTools: Do not use sideband when sending an error but use an error packet always<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance improvements<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/560527\">560527<\/a> Expose FileStoreAttributes.setBackground()<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/560414\">560414<\/a> Revert &quot;Prepend hostname to subsection used to store file timestamp resolution&quot;<\/li>\r\n\t<li>AmazonS3: Speed up fetch, try recent packs first<\/li>\r\n\t<li>Using StringBuilder in StringUtils#capitalize method<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/558577\">558577<\/a> Cygwin expects forward slashes for commands to be run via sh.exe<\/li>\r\n\t<li>ObjectWalk: Add null check before skip tree.<\/li>\r\n\t<li>JSch ssh client: do not fail if known hosts file does not contain valid host key<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/551690\">551690<\/a> FS: Don&#39;t use innocuous threads for CompletableFuture<\/li>\r\n\t<li>Fix SshSessionFactory#setInstance to use service loader<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553625\">553625<\/a> Use ServiceLoader to define the default SSH session factory.<\/li>\r\n\t<li>UploadPackServlet: Use uploadWithExceptionPropagation<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and release engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bump Bazel version to 2.2.0<\/li>\r\n\t<li>Update bazlets and bazel version<\/li>\r\n\t<li>Add 4.14 and 4.15-staging target platforms<\/li>\r\n\t<li>Update Orbit to R20200224183213 for 2020-03<\/li>\r\n\t<li>Remove use of org.bouncycastle.util.encoders.Hex<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/559106\">559106<\/a> Remove use of org.bouncycastle.util.io.TeeOutputStream<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/559735\">559735<\/a> Include org.apache.commons.codec 1.13 in the JGit http.apache.feature<\/li>\r\n\t<li>Upgrade plexus-compiler-{eclipse|javac|javac-errorprone} to 2.8.6<\/li>\r\n\t<li>Upgrade maven-shade-plugin to 3.2.2<\/li>\r\n\t<li>Upgrade maven-pmd-plugin to 3.13.0<\/li>\r\n\t<li>Update maven-surefire-plugin to 3.0.0-M4<\/li>\r\n\t<li>Update japicmp-maven-plugin to 0.14.3<\/li>\r\n\t<li>Update org.junit to 4.13.0.v20200126-2018<\/li>\r\n\t<li>Replace ExpectedException which was deprecated in junit 4.13<\/li>\r\n\t<li>Replace deprecated junit assertion methods with hamcrest<\/li>\r\n\t<li>Add org.assertj 3.14.0.v20200120-1926 to target platform<\/li>\r\n\t<li>Update to Tycho 1.6.0<\/li>\r\n\t<li>Update javaewah to 1.1.7.v20200107-0831<\/li>\r\n\t<li>Update org.apache.commons.codec to 1.13.0.v20200108-0001<\/li>\r\n\t<li>Update org.apache.commons.compress to 1.19.0.v20200106-2343<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpclient to 4.5.10.v20200114-1512<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpcore to 4.4.12.v20200108-1212<\/li>\r\n\t<li>Upgrade jetty to 9.4.25.v20191220<\/li>\r\n\t<li>Update spring-boot-maven-plugin to 2.1.5.RELEASE<\/li>\r\n\t<li>Upgrade maven-source-plugin to 3.2.1<\/li>\r\n\t<li>Upgrade ecj to 3.20.0<\/li>\r\n\t<li>Upgrade error_prone_core to 2.3.4<\/li>\r\n\t<li>ErrorProne: Enable and fix UnusedException check<\/li>\r\n\t<li>Add resource preferences for top level jgit project<\/li>\r\n\t<li>ReceivePack: Move connectivity check to separate class<\/li>\r\n\t<li>[releng] Update year in copyright notices for features<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/548298\">548298<\/a> Update EDL 1.0 license headers to new short SPDX compliant format<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-03-18 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.7.0"}],"state":[{"value":"pending"}],"title":"5.7.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.7.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.7.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.7.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-02-13 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Monitoring enhancements<\/h2>\n<ul><li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add metric for cached bytes per repository<\/li>\n<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add option to use strong refs to reference ByteWindows<br \/>\n\tSet core.packedGitUseStrongRefs = true to enable using strong references to reference packfile pages cached in the WindowCache. If this option is set Java gc can no longer flush the WindowCache to free memory if the used heap comes close to the maximum heap size. On the other hand this provides more predictable performance.<\/li>\n<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> Enhance WindowCache statistics<\/li>\n<li>Add config constants for WindowCache configuration options<\/li>\n<\/ul><h2>Performance improvements<\/h2>\n<ul><li>Replace usage of ArrayIndexOutOfBoundsException in treewalk<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li>Simplify ReftableCompactor<\/li>\n<li>reftable: don't check deadline on the first try<\/li>\n<li>reftable: clear cache on full compaction<\/li>\n<li><a href=\"https:\/\/eclip.se\/559796\">559796<\/a> Restore behavior of CloneCommand to configure fetch refspec with wildcards<\/li>\n<li><a href=\"https:\/\/eclip.se\/558577\">558577<\/a> Hooks: avoid problems with backslashes in paths<\/li>\n<li>Fix MBean registration<\/li>\n<li>pgm daemon: fallback to user and system config if no config specified<\/li>\n<li>SshSupport#runSshCommand: don't throw exception in finally block<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bump required Bazel version to 2.1.0<\/li>\n<li>Upgrade bazlets to the latest master revision<\/li>\n<li>Don't override already managed maven-compiler-plugin version<\/li>\n<li>Remove duplicate ignore_optional_problems entry in .classpath<\/li>\n<li>Update maven-site-plugin used by benchmark module to 3.8.2<\/li>\n<li>Add dependency to enable site generation for benchmark module<\/li>\n<li>Ignore warnings for generated source code in org.eclipse.jgit.benchmark<\/li>\n<\/ul>","summary":"","value":"<h2>Monitoring enhancements<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a>&nbsp;WindowCache: add metric for cached bytes per repository<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a>&nbsp;WindowCache: add option to use strong refs to reference ByteWindows<br \/>\r\n\tSet core.packedGitUseStrongRefs = true to enable using strong references to reference packfile pages cached in the WindowCache.&nbsp;If this option is set Java gc can no longer flush the&nbsp;WindowCache to free memory if the used heap comes close to the maximum heap size. On the other hand this provides more predictable performance.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a>&nbsp;Enhance WindowCache statistics<\/li>\r\n\t<li>Add config constants for WindowCache configuration options<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace usage of ArrayIndexOutOfBoundsException in treewalk<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Simplify ReftableCompactor<\/li>\r\n\t<li>reftable: don&#39;t check deadline on the first try<\/li>\r\n\t<li>reftable: clear cache on full compaction<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/559796\">559796<\/a> Restore behavior of CloneCommand to configure fetch refspec with wildcards<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/558577\">558577<\/a> Hooks: avoid problems with backslashes in paths<\/li>\r\n\t<li>Fix MBean registration<\/li>\r\n\t<li>pgm daemon: fallback to user and system config if no config specified<\/li>\r\n\t<li>SshSupport#runSshCommand: don&#39;t throw exception in finally block<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bump required Bazel version to 2.1.0<\/li>\r\n\t<li>Upgrade bazlets to the latest master revision<\/li>\r\n\t<li>Don&#39;t override already managed maven-compiler-plugin version<\/li>\r\n\t<li>Remove duplicate ignore_optional_problems entry in .classpath<\/li>\r\n\t<li>Update maven-site-plugin used by benchmark module to 3.8.2<\/li>\r\n\t<li>Add dependency to enable site generation for benchmark module<\/li>\r\n\t<li>Ignore warnings for generated source code in org.eclipse.jgit.benchmark<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.6.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.6.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-02-11 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Monitoring enhancements<\/h2>\n<ul><li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add metric for cached bytes per repository<\/li>\n<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add option to use strong refs to reference ByteWindows<br \/>\n\tSet core.packedGitUseStrongRefs = true to enable using strong references to reference packfile pages cached in the WindowCache. If this option is set Java gc can no longer flush the WindowCache to free memory if the used heap comes close to the maximum heap size. On the other hand this provides more predictable performance.<\/li>\n<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> Enhance WindowCache statistics<\/li>\n<li>Add config constants for WindowCache configuration options<\/li>\n<\/ul><h2>Performance improvements<\/h2>\n<ul><li>Replace usage of ArrayIndexOutOfBoundsException in treewalk<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li>Fix string format parameter for invalidRefAdvertisementLine<\/li>\n<li>pgm daemon: fallback to user and system config if no config specified<\/li>\n<li>SshSupport#runSshCommand: don't throw exception in finally block<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Don't override already managed maven-compiler-plugin version<\/li>\n<li>Remove duplicate ignore_optional_problems entry in .classpath<\/li>\n<li>Update maven-site-plugin used by benchmark module to 3.8.2<\/li>\n<li>Add dependency to enable site generation for benchmark module<\/li>\n<li>Bazel: Use java_plugin and java_binary from @rules_java in jmh.bzl<\/li>\n<li>Fix benchmark pom.xml to include distribution managment config<\/li>\n<li>Run JMH benchmarks using bazel<\/li>\n<li>Benchmark for creating files and FileSnapshots<\/li>\n<li>Implement benchmark for looking up FileStore of a given Path<\/li>\n<li>JMH benchmark for SimpleLruCache<\/li>\n<\/ul>","summary":"","value":"<h2>Monitoring enhancements<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a>&nbsp;WindowCache: add metric for cached bytes per repository<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a>&nbsp;WindowCache: add option to use strong refs to reference ByteWindows<br \/>\r\n\tSet core.packedGitUseStrongRefs = true to enable using strong references to reference packfile pages cached in the WindowCache.&nbsp;If this option is set Java gc can no longer flush the&nbsp;WindowCache to free memory if the used heap comes close to the maximum heap size. On the other hand this provides more predictable performance.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a>&nbsp;Enhance WindowCache statistics<\/li>\r\n\t<li>Add config constants for WindowCache configuration options<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace usage of ArrayIndexOutOfBoundsException in treewalk<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix string format parameter for invalidRefAdvertisementLine<\/li>\r\n\t<li>pgm daemon: fallback to user and system config if no config specified<\/li>\r\n\t<li>SshSupport#runSshCommand: don&#39;t throw exception in finally block<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Don&#39;t override already managed maven-compiler-plugin version<\/li>\r\n\t<li>Remove duplicate ignore_optional_problems entry in .classpath<\/li>\r\n\t<li>Update maven-site-plugin used by benchmark module to 3.8.2<\/li>\r\n\t<li>Add dependency to enable site generation for benchmark module<\/li>\r\n\t<li>Bazel: Use java_plugin and java_binary from @rules_java in jmh.bzl<\/li>\r\n\t<li>Fix benchmark pom.xml to include distribution managment config<\/li>\r\n\t<li>Run JMH benchmarks using bazel<\/li>\r\n\t<li>Benchmark for creating files and FileSnapshots<\/li>\r\n\t<li>Implement benchmark for looking up FileStore of a given Path<\/li>\r\n\t<li>JMH benchmark for SimpleLruCache<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.7","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-02-11 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Monitoring enhancements<\/h2>\n<ul><li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add metric for cached bytes per repository<\/li>\n<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add option to use strong refs to reference ByteWindows<br \/>\n\tSet core.packedGitUseStrongRefs = true to enable using strong references to reference packfile pages cached in the WindowCache. If this option is set Java gc can no longer flush the WindowCache to free memory if the used heap comes close to the maximum heap size. On the other hand this provides more predictable performance.<\/li>\n<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> Enhance WindowCache statistics<\/li>\n<li>Add config constants for WindowCache configuration options<\/li>\n<\/ul><h2>Performance improvements<\/h2>\n<ul><li>Replace usage of ArrayIndexOutOfBoundsException in treewalk<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li>Fix string format parameter for invalidRefAdvertisementLine<\/li>\n<li>pgm daemon: fallback to user and system config if no config specified<\/li>\n<li>SshSupport#runSshCommand: don't throw exception in finally block<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Don't override already managed maven-compiler-plugin version<\/li>\n<li>Remove duplicate ignore_optional_problems entry in .classpath<\/li>\n<li>Update maven-site-plugin used by benchmark module to 3.8.2<\/li>\n<li>Add dependency to enable site generation for benchmark module<\/li>\n<li>Bazel: Use java_plugin and java_binary from @rules_java in jmh.bzl<\/li>\n<li>Fix benchmark pom.xml to include distribution managment config<\/li>\n<li>Run JMH benchmarks using bazel<\/li>\n<li>Benchmark for creating files and FileSnapshots<\/li>\n<li>Implement benchmark for looking up FileStore of a given Path<\/li>\n<li>JMH benchmark for SimpleLruCache<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Monitoring enhancements<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add metric for cached bytes per repository<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> WindowCache: add option to use strong refs to reference ByteWindows<br \/>\r\n\tSet core.packedGitUseStrongRefs = true to enable using strong references to reference packfile pages cached in the WindowCache.&nbsp;If this option is set Java gc can no longer flush the&nbsp;WindowCache to free memory if the used heap comes close to the maximum heap size. On the other hand this provides more predictable performance.<\/li>\r\n\t<li><a href=\"https:\/\/eclip.se\/553573\">553573<\/a> Enhance WindowCache statistics<\/li>\r\n\t<li>Add config constants for WindowCache configuration options<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace usage of ArrayIndexOutOfBoundsException in treewalk<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix string format parameter for invalidRefAdvertisementLine<\/li>\r\n\t<li>pgm daemon: fallback to user and system config if no config specified<\/li>\r\n\t<li>SshSupport#runSshCommand: don&#39;t throw exception in finally block<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Don&#39;t override already managed maven-compiler-plugin version<\/li>\r\n\t<li>Remove duplicate ignore_optional_problems entry in .classpath<\/li>\r\n\t<li>Update maven-site-plugin used by benchmark module to 3.8.2<\/li>\r\n\t<li>Add dependency to enable site generation for benchmark module<\/li>\r\n\t<li>Bazel: Use java_plugin and java_binary from @rules_java in jmh.bzl<\/li>\r\n\t<li>Fix benchmark pom.xml to include distribution managment config<\/li>\r\n\t<li>Run JMH benchmarks using bazel<\/li>\r\n\t<li>Benchmark for creating files and FileSnapshots<\/li>\r\n\t<li>Implement benchmark for looking up FileStore of a given Path<\/li>\r\n\t<li>JMH benchmark for SimpleLruCache<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.13","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.13","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-12-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<h3>Reftable<\/h3>\n<ul><li>Implement FileReftableDatabase<br \/>\n\tReftable is a binary, block-based storage format for the ref-database. It provides several advantages over the traditional packed + loose refs storage<br \/>\n\tStorage format:\n<ul><li>O(1) write performance, even for deletions and transactions.<\/li>\n<li>atomic updates to the ref database.<\/li>\n<li>O(log N) lookup and prefix scans<\/li>\n<li>free from restrictions imposed by the file system: it is case-sensitive even on case-insensitive file systems, and has no inherent limitations for directory\/file conflicts<\/li>\n<\/ul><\/li>\n<li>prefix compression reduces space usage for repetitive ref names, such as gerrit's refs\/changes\/xx\/xxxxx format.<\/li>\n<li>FileReftableDatabase is based on FileReftableStack, which does compactions inline. This is simple, and has good median performance, but every so often it will rewrite the entire ref database.<\/li>\n<li>Add FileRepository#convertToReftable so existing testdata can be reused.<\/li>\n<li>pgm: add write stats to BenchmarkReftable<\/li>\n<li>pgm: add command to convert repo to reftable<\/li>\n<li>reftable: enforce ascending order in sortAndWriteRefs<\/li>\n<li>Documentation\/technical\/reftable: document rename in reflog<\/li>\n<li>Introduce RefDatabase#hasFastTipsWithSha1<\/li>\n<\/ul><h3>Other Features<\/h3>\n<ul><li><a href=\"https:\/\/www.eclip.se\/553471\">553471<\/a> Add ability to redirect stderr from git hooks<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/553469\">553469<\/a> Add possibility to get pure stderr output from AbortedByHookException<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/500266\">500266<\/a> Support for core.hooksPath<\/li>\n<li>JGit pgm: Add support for excluding paths from Git log command<\/li>\n<li>JGit pgm: Format blame output to match canonical git<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552173\">552173<\/a> pgm: Add --mirror option to clone command<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552173\">552173<\/a> Implement mirror option in CloneCommand<\/li>\n<li>RepositoryCache: don't require HEAD in git repositories using reftable<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552467\">552467<\/a> DiffFormatter: support core.quotePath = false<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/550878\">550878<\/a> IndexDiff\/SubmoduleWalk: make the RepositoryBuilder configurable<\/li>\n<li>transport: Merge BaseReceivePack into ReceivePack<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/551850\">551850<\/a> Store filesystem timestamp resolution in extra jgit config $XDG_CONFIG_HOME\/jgit\/config<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/550335\">550335<\/a> GPG: implement more OpenPGP UserId matching formats<\/li>\n<li>ProtocolV2Parser: Introduce advertise sideband-all option<\/li>\n<li>PackWriter\/Statistics: Report offloaded size<\/li>\n<li>CachedPackUriProvider: Add size to the pack information<\/li>\n<li>http: Allow specifying a custom error handler for UploadPack<\/li>\n<li>UploadPack: Introduce ErrorWriter<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/549832\">549832<\/a> Apache HTTP: support proxy authentication<\/li>\n<li>DfsCachedPack: Add accessor for packfile object<\/li>\n<li>dfs: Take size as long instead of int in the DfsBlockCache<\/li>\n<\/ul><h2>Performance and memory consumption improvements<\/h2>\n<ul><li>BitmappedReachabilityChecker: Use only one bitmap for the whole check<\/li>\n<li>checkNotAdvertisedWants: Be lazy converting Ref to RevCommit to reduce the latency for reachability checks over big sets of references<\/li>\n<li>UploadPack: Prioritize references for non-advertised wants checks<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/www.eclip.se\/434330\">434330<\/a> Make blame work correctly on merge conflicts<\/li>\n<li>[spotbugs] Fix potential NPE in FSTest<\/li>\n<li>UploadPackTest: Fix unused parameter in checkUnadvertisedIfUnallowed<\/li>\n<li>TopoSortGenerator: simplify first-parent handling<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552160\">552160<\/a> RewriteGenerator: avoid adding null parent to avoid NPE<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/521613\">521613<\/a> IndexDiff\/SubmoduleWalk: handle submodule.&lt;name&gt;.ignore correctly<\/li>\n<li>BaseReceivePack: Add hasReceivedPack method to enable avoiding IllegalStateException if getPackSize is called when the pack size is not set<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/551850\">551850<\/a> Prepend hostname to config subsection used to store file timestamp resolution<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552636\">552636<\/a> WorkingTreeModifiedEvent: must be fired explicitly after merge<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/549690\">549690<\/a> HttpSupport.proxyFor(): use only scheme, host, and port<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552288\">552288<\/a> GpgKeyLocator: Return a signing key for a user instead of the master key<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/552288\">552288<\/a> GpgKeyLocator: Return subkeys instead of the first key for subkeys<\/li>\n<li>AppServer: Stop using deprecated SslContextFactory constructor<\/li>\n<li>IndexDiff: close SubmoduleWalk and use already loaded DirCache<\/li>\n<li>CachedPackUriProvider: size should be a long (not an int)<\/li>\n<li><a href=\"https:\/\/www.eclip.se\/551664\">551664<\/a> Fix parsing of core.logAllRefUpdates<\/li>\n<li>Fix NPE in DfsPackCompactor.compactReftables<\/li>\n<li>Fire WorkingTreeModifiedEvent if cherry-pick failed with conflicts<\/li>\n<li>Remove an old work-around for core.autocrlf = input<\/li>\n<li>ReceivePack: Prevent pointing a branch to a non-commit object<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Update bouncycastle version to 1.64<\/li>\n<li>Upgrade Jetty to 9.4.22.v20191022<\/li>\n<li>Use Java 8 source and target in Maven<\/li>\n<li>Update Orbit to R20191126223242 for 2019-12<\/li>\n<li>Upgrade maven-enforcer-plugin to 3.0.0-M3<\/li>\n<li>Upgrade maven-jar-plugin to 3.2.0<\/li>\n<li>Upgrade maven-source-plugin to 3.2.0<\/li>\n<li>Upgrade jacoco-maven-plugin to 0.8.5<\/li>\n<li>Upgrade ecj plugin to 3.19.0<\/li>\n<li>Upgrade eclipse-jarsigner-plugin to 1.1.7<\/li>\n<li>Upgrade wagon-ssh to 3.3.4<\/li>\n<li>Update Tycho to 1.5.1<\/li>\n<li>Require Maven version 3.6.2<\/li>\n<li>Bazel: Bump bazel version to 1.0.0<\/li>\n<li>Bazel: Use java_plugin and java_binary from @rules_java in jmh.bzl<\/li>\n<li>Bazel: Reuse version from .bazelversion for minimum used version check<\/li>\n<li>Move KetchSystem.delay to FileUtils.<\/li>\n<li>Fix benchmark pom.xml to include distribution managment config<\/li>\n<li>Run JMH benchmarks using bazel<\/li>\n<li>Benchmark for creating files and FileSnapshots<\/li>\n<li>Implement benchmark for looking up FileStore of a given Path<\/li>\n<li>JMH benchmark for SimpleLruCache<\/li>\n<li>Create 4.14 staging target platform<\/li>\n<li>Rename servlet-api-3_1 to match Gerrit master<\/li>\n<li>Update Eclipse SUA to latest 2.0 version<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<h3>Reftable<\/h3>\r\n\r\n<ul>\r\n\t<li>Implement FileReftableDatabase<br \/>\r\n\tReftable is a binary, block-based storage format for the ref-database. It provides several advantages over the traditional packed + loose refs storage<br \/>\r\n\tStorage format:\r\n\t<ul>\r\n\t\t<li>O(1) write performance, even for deletions and transactions.<\/li>\r\n\t\t<li>atomic updates to the ref database.<\/li>\r\n\t\t<li>O(log N) lookup and prefix scans<\/li>\r\n\t\t<li>free from restrictions imposed by the file system: it is case-sensitive even on case-insensitive file systems, and has&nbsp;no inherent limitations for directory\/file conflicts<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>prefix compression reduces space usage for repetitive ref names, such as gerrit&#39;s refs\/changes\/xx\/xxxxx format.<\/li>\r\n\t<li>FileReftableDatabase is based on FileReftableStack, which does&nbsp;compactions inline. This is simple, and has good median performance,&nbsp;but every so often it will rewrite the entire ref database.<\/li>\r\n\t<li>Add FileRepository#convertToReftable so existing testdata can be reused.<\/li>\r\n\t<li>pgm: add write stats to BenchmarkReftable<\/li>\r\n\t<li>pgm: add command to convert repo to reftable<\/li>\r\n\t<li>reftable: enforce ascending order in sortAndWriteRefs<\/li>\r\n\t<li>Documentation\/technical\/reftable: document rename in reflog<\/li>\r\n\t<li>Introduce RefDatabase#hasFastTipsWithSha1<\/li>\r\n<\/ul>\r\n\r\n<h3>Other Features<\/h3>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553471\">553471<\/a> Add ability to redirect stderr from git hooks<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/553469\">553469<\/a> Add possibility to get pure stderr output from AbortedByHookException<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/500266\">500266<\/a> Support for core.hooksPath<\/li>\r\n\t<li>JGit pgm: Add support for excluding paths from Git log command<\/li>\r\n\t<li>JGit pgm: Format blame output to match canonical git<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552173\">552173<\/a> pgm: Add --mirror option to clone command<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552173\">552173<\/a> Implement mirror option in CloneCommand<\/li>\r\n\t<li>RepositoryCache: don&#39;t require HEAD in git repositories using reftable<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552467\">552467<\/a> DiffFormatter: support core.quotePath = false<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/550878\">550878<\/a> IndexDiff\/SubmoduleWalk: make the RepositoryBuilder configurable<\/li>\r\n\t<li>transport: Merge BaseReceivePack into ReceivePack<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/551850\">551850<\/a> Store filesystem timestamp resolution in extra jgit config $XDG_CONFIG_HOME\/jgit\/config<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/550335\">550335<\/a> GPG: implement more OpenPGP UserId matching formats<\/li>\r\n\t<li>ProtocolV2Parser: Introduce advertise sideband-all option<\/li>\r\n\t<li>PackWriter\/Statistics: Report offloaded size<\/li>\r\n\t<li>CachedPackUriProvider: Add size to the pack information<\/li>\r\n\t<li>http: Allow specifying a custom error handler for UploadPack<\/li>\r\n\t<li>UploadPack: Introduce ErrorWriter<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/549832\">549832<\/a> Apache HTTP: support proxy authentication<\/li>\r\n\t<li>DfsCachedPack: Add accessor for packfile object<\/li>\r\n\t<li>dfs: Take size as long instead of int in the DfsBlockCache<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance and memory consumption improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>BitmappedReachabilityChecker: Use only one bitmap for the whole check<\/li>\r\n\t<li>checkNotAdvertisedWants: Be lazy converting Ref to RevCommit to reduce the latency for reachability checks over big sets of references<\/li>\r\n\t<li>UploadPack: Prioritize references for non-advertised wants checks<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/434330\">434330<\/a> Make blame work correctly on merge conflicts<\/li>\r\n\t<li>[spotbugs] Fix potential NPE in FSTest<\/li>\r\n\t<li>UploadPackTest: Fix unused parameter in checkUnadvertisedIfUnallowed<\/li>\r\n\t<li>TopoSortGenerator: simplify first-parent handling<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552160\">552160<\/a> RewriteGenerator: avoid adding null parent to avoid NPE<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/521613\">521613<\/a> IndexDiff\/SubmoduleWalk: handle submodule.&lt;name&gt;.ignore correctly<\/li>\r\n\t<li>BaseReceivePack: Add hasReceivedPack method to enable avoiding IllegalStateException if getPackSize is called when the pack size is not set<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/551850\">551850<\/a> Prepend hostname to config subsection used to store file timestamp resolution<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552636\">552636<\/a> WorkingTreeModifiedEvent: must be fired explicitly after merge<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/549690\">549690<\/a> HttpSupport.proxyFor(): use only scheme, host, and port<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552288\">552288<\/a> GpgKeyLocator: Return a signing key for a user instead of the master key<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/552288\">552288<\/a> GpgKeyLocator: Return subkeys instead of the first key for subkeys<\/li>\r\n\t<li>AppServer: Stop using deprecated SslContextFactory constructor<\/li>\r\n\t<li>IndexDiff: close SubmoduleWalk and use already loaded DirCache<\/li>\r\n\t<li>CachedPackUriProvider: size should be a long (not an int)<\/li>\r\n\t<li><a href=\"https:\/\/www.eclip.se\/551664\">551664<\/a> Fix parsing of core.logAllRefUpdates<\/li>\r\n\t<li>Fix NPE in DfsPackCompactor.compactReftables<\/li>\r\n\t<li>Fire WorkingTreeModifiedEvent if cherry-pick failed with conflicts<\/li>\r\n\t<li>Remove an old work-around for core.autocrlf = input<\/li>\r\n\t<li>ReceivePack: Prevent pointing a branch to a non-commit object<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Update bouncycastle version to 1.64<\/li>\r\n\t<li>Upgrade Jetty to 9.4.22.v20191022<\/li>\r\n\t<li>Use Java 8 source and target in Maven<\/li>\r\n\t<li>Update Orbit to R20191126223242 for 2019-12<\/li>\r\n\t<li>Upgrade maven-enforcer-plugin to 3.0.0-M3<\/li>\r\n\t<li>Upgrade maven-jar-plugin to 3.2.0<\/li>\r\n\t<li>Upgrade maven-source-plugin to 3.2.0<\/li>\r\n\t<li>Upgrade jacoco-maven-plugin to 0.8.5<\/li>\r\n\t<li>Upgrade ecj plugin to 3.19.0<\/li>\r\n\t<li>Upgrade eclipse-jarsigner-plugin to 1.1.7<\/li>\r\n\t<li>Upgrade wagon-ssh to 3.3.4<\/li>\r\n\t<li>Update Tycho to 1.5.1<\/li>\r\n\t<li>Require Maven version 3.6.2<\/li>\r\n\t<li>Bazel: Bump bazel version to 1.0.0<\/li>\r\n\t<li>Bazel: Use java_plugin and java_binary from @rules_java in jmh.bzl<\/li>\r\n\t<li>Bazel: Reuse version from .bazelversion for minimum used version check<\/li>\r\n\t<li>Move KetchSystem.delay to FileUtils.<\/li>\r\n\t<li>Fix benchmark pom.xml to include distribution managment config<\/li>\r\n\t<li>Run JMH benchmarks using bazel<\/li>\r\n\t<li>Benchmark for creating files and FileSnapshots<\/li>\r\n\t<li>Implement benchmark for looking up FileStore of a given Path<\/li>\r\n\t<li>JMH benchmark for SimpleLruCache<\/li>\r\n\t<li>Create 4.14 staging target platform<\/li>\r\n\t<li>Rename servlet-api-3_1 to match Gerrit master<\/li>\r\n\t<li>Update Eclipse SUA to latest 2.0 version<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"289"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-12-18 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.6.0"}],"state":[{"value":"success"}],"title":"5.6.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.6.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.6.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.6.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-10-02 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p>Do not rely on ArrayIndexOutOfBoundsException to detect end of input. Config#StringReader relied on ArrayIndexOutOfBoundsException to detect the end of the input. Creation of exception with (deep) stack trace can significantly degrade performance e.g. when Gerrit reads all external ids from NoteDb.<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/www.eclipse.org\/forums\/index.php\/t\/1100344\/\">1100344<\/a> WorkingTreeIterator: correctly handle different timestamp resolutions<\/p>\n<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>Do not rely on ArrayIndexOutOfBoundsException to detect end of input. Config#StringReader relied on ArrayIndexOutOfBoundsException&nbsp;to detect the end of the input. Creation of exception with (deep) stack trace can significantly degrade performance e.g. when Gerrit reads all external ids from NoteDb.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/www.eclipse.org\/forums\/index.php\/t\/1100344\/\">1100344<\/a> WorkingTreeIterator: correctly handle different timestamp resolutions<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.5.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.5.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-10-02 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p>Do not rely on ArrayIndexOutOfBoundsException to detect end of input. Config#StringReader relied on ArrayIndexOutOfBoundsException to detect the end of the input. Creation of exception with (deep) stack trace can significantly degrade performance e.g. when Gerrit reads all external ids from NoteDb.<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/www.eclipse.org\/forums\/index.php\/t\/1100344\/\">1100344<\/a> WorkingTreeIterator: correctly handle different timestamp resolutions<\/p>\n<\/li>\n<li>\n<p>Fix WorkingTreeIterator.compareMetadata() for CheckStat.MINIMAL<\/p>\n<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Add fixes for --incompatible_load_java_rules_from_bzl<\/li>\n<li>Bazel: Bump minimum supported version to 0.29.0<\/li>\n<li>Use bazelisk to switch between used bazel version<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>Do not rely on ArrayIndexOutOfBoundsException to detect end of input. Config#StringReader relied on ArrayIndexOutOfBoundsException&nbsp;to detect the end of the input. Creation of exception with (deep) stack trace can significantly degrade performance e.g. when Gerrit reads all external ids from NoteDb.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/www.eclipse.org\/forums\/index.php\/t\/1100344\/\">1100344<\/a> WorkingTreeIterator: correctly handle different timestamp resolutions<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Fix WorkingTreeIterator.compareMetadata() for CheckStat.MINIMAL<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Add fixes for --incompatible_load_java_rules_from_bzl<\/li>\r\n\t<li>Bazel: Bump minimum supported version to 0.29.0<\/li>\r\n\t<li>Use bazelisk to switch between used bazel version<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.6","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-10-01 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p>Do not rely on ArrayIndexOutOfBoundsException to detect end of input. Config#StringReader relied on ArrayIndexOutOfBoundsException to detect the end of the input. Creation of exception with (deep) stack trace can significantly degrade performance e.g. when Gerrit reads all external ids from NoteDb.<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/www.eclipse.org\/forums\/index.php\/t\/1100344\/\">1100344<\/a> WorkingTreeIterator: correctly handle different timestamp resolutions<\/p>\n<\/li>\n<li>\n<p>Fix WorkingTreeIterator.compareMetadata() for CheckStat.MINIMAL<\/p>\n<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Add fixes for --incompatible_load_java_rules_from_bzl<\/li>\n<li>Bazel: Bump minimum supported version to 0.29.0<\/li>\n<li>Use bazelisk to switch between used bazel version<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>Do not rely on ArrayIndexOutOfBoundsException to detect end of input. Config#StringReader relied on ArrayIndexOutOfBoundsException&nbsp;to detect the end of the input. Creation of exception with (deep) stack trace can significantly degrade performance e.g. when Gerrit reads all external ids from NoteDb.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/www.eclipse.org\/forums\/index.php\/t\/1100344\/\">1100344<\/a> WorkingTreeIterator: correctly handle different timestamp resolutions<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Fix WorkingTreeIterator.compareMetadata() for CheckStat.MINIMAL<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Add fixes for --incompatible_load_java_rules_from_bzl<\/li>\r\n\t<li>Bazel: Bump minimum supported version to 0.29.0<\/li>\r\n\t<li>Use bazelisk to switch between used bazel version<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.12","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.12","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548492\">548492<\/a> sshd: support the HashKnownHosts configuration<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547619\">547619<\/a> sshd: configurable server key verification<\/li>\n<li>sshd: allow setting a null ssh config<\/li>\n<li>UploadPack: support custom packfile-to-URI mapping<\/li>\n<li>UploadPack: support lazy fetches if no bitmap available<\/li>\n<li>reftable improvements\n<ul><li>increment pointer *after* reading uint16<\/li>\n<li>test absense of prefix matching in Reflog<\/li>\n<li>enforce ordering for ref and log writes<\/li>\n<li>fix seeking to refs in reflog implementation<\/li>\n<\/ul><\/li>\n<li>protocol V2 enhancements:\n<ul><li>UploadPack: add getProtocolV2Hook() method<\/li>\n<li>ProtocolV2HookChain: Allow to create a chain of protocol V2 hooks<\/li>\n<li>Support \"sideband-all\" in protocol v2 fetch<\/li>\n<\/ul><\/li>\n<li>RevWalk: Add a setFirstParent that mimics C git's --first-parent<\/li>\n<\/ul><h2>Bug fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548965\">548965<\/a> sshd: fix proxy connections with the DefaultProxyDataFactory<\/li>\n<li>sshd: shared reference in JGitClientSession must be volatile<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545939\">545939<\/a> sshd: correct the protocol version exchange<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548503\">548503<\/a> Fix bundle localization of Apache SSH bundle<\/li>\n<li>RevWalk: Traverse all parents of UNINTERESTING commits<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=490798\">490798<\/a> JGit pgm: make Blame more robust against bogus input<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544326\">544326<\/a> JGit pgm tests must quote paths on the command line<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550115\">550115<\/a> Fix error occurring when SecurityManager is enabled<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548219\">548219<\/a> Fix ApplyCommand which doesn't work if patch adds empty file<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550033\">550033<\/a> TransportHttp: resolve redirect URIs from the \"Location\" header<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=549439\">549439<\/a> GPG: also consider pubring.gpg when looking for keys<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=549439\">549439<\/a> GPG: check secring.gpg for keys if pubring.kbx is empty<\/li>\n<li>JschConfigSessionFactory: [findbugs] synchronize config access<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=479266\">479266<\/a> Fix \"reset -hard\" bug that folders could not be deleted<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=479266\">479266<\/a> Fix \"reset -hard\" bug that folders could not be created<\/li>\n<li>Walk tag chains for --include-tag options to fix packfile corruption when cloning with --single-branch option<\/li>\n<\/ul><h2>Build and release engineering<\/h2>\n<ul><li>update Orbit to S20190827152740 for 2019-09 RC1<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550094\">550094<\/a> Update Jetty to 9.4.20.v20190813<\/li>\n<li>update org.mockito to 2.23.0.v20190527-1420<\/li>\n<li>update net.bytebuddy.byte-buddy to 1.9.0.v20181107-1410<\/li>\n<li>update net.bytebuddy.byte-buddy-agent to 1.9.0.v20181106-1534<\/li>\n<li>upgrade eclipse-jarsigner-plugin to 1.1.6<\/li>\n<li>upgrade maven-javadoc-plugin to 3.1.1<\/li>\n<li>upgrade maven-site-plugin to 3.8.2<\/li>\n<li>upgrade spotbugs to 3.1.12.2<\/li>\n<li>upgrade ecj to 3.18.0<\/li>\n<li>upgrade wagon-ssh to 3.3.3<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=450485\">450485<\/a> Use https in update site URLs<\/li>\n<li>Apache HTTP: run more tests<\/li>\n<li>delete outdated Orbit target platform definitions<\/li>\n<li>add assertThrows that will be introduced in JUnit 4.13<\/li>\n<li>update bazlets to latest version<\/li>\n<li>[Java 9] Fix GitDateFormatterTest<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540790\">540790<\/a> [Java 11] Remove dependency on javax.xml.bind package<\/li>\n<li>Ignore warning that tests don't export all packages<\/li>\n<li>Ensure all packages are exported<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548492\">548492<\/a> sshd: support the HashKnownHosts configuration<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547619\">547619<\/a> sshd: configurable server key verification<\/li>\r\n\t<li>sshd: allow setting a null ssh config<\/li>\r\n\t<li>UploadPack: support custom packfile-to-URI mapping<\/li>\r\n\t<li>UploadPack: support lazy fetches if no bitmap available<\/li>\r\n\t<li>reftable improvements\r\n\t<ul>\r\n\t\t<li>increment pointer *after* reading uint16<\/li>\r\n\t\t<li>test absense of prefix matching in Reflog<\/li>\r\n\t\t<li>enforce ordering for ref and log writes<\/li>\r\n\t\t<li>fix seeking to refs in reflog implementation<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>protocol V2 enhancements:\r\n\t<ul>\r\n\t\t<li>UploadPack: add getProtocolV2Hook() method<\/li>\r\n\t\t<li>ProtocolV2HookChain: Allow to create a chain of protocol V2 hooks<\/li>\r\n\t\t<li>Support &quot;sideband-all&quot; in protocol v2 fetch<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>RevWalk: Add a setFirstParent that mimics C git&#39;s --first-parent<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548965\">548965<\/a> sshd: fix proxy connections with the DefaultProxyDataFactory<\/li>\r\n\t<li>sshd: shared reference in JGitClientSession must be volatile<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545939\">545939<\/a> sshd: correct the protocol version exchange<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548503\">548503<\/a> Fix bundle localization of Apache SSH bundle<\/li>\r\n\t<li>RevWalk: Traverse all parents of UNINTERESTING commits<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=490798\">490798<\/a> JGit pgm: make Blame more robust against bogus input<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544326\">544326<\/a> JGit pgm tests must quote paths on the command line<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550115\">550115<\/a> Fix error occurring when SecurityManager is enabled<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548219\">548219<\/a> Fix ApplyCommand which doesn&#39;t work if patch adds empty file<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550033\">550033<\/a> TransportHttp: resolve redirect URIs from the &quot;Location&quot; header<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=549439\">549439<\/a> GPG: also consider pubring.gpg when looking for keys<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=549439\">549439<\/a> GPG: check secring.gpg for keys if pubring.kbx is empty<\/li>\r\n\t<li>JschConfigSessionFactory: [findbugs] synchronize config access<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=479266\">479266<\/a> Fix &quot;reset -hard&quot; bug that folders could not be deleted<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=479266\">479266<\/a> Fix &quot;reset -hard&quot; bug that folders could not be created<\/li>\r\n\t<li>Walk tag chains for --include-tag options to fix packfile corruption when cloning with --single-branch option<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and release engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>update Orbit to S20190827152740 for 2019-09 RC1<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550094\">550094<\/a> Update Jetty to 9.4.20.v20190813<\/li>\r\n\t<li>update org.mockito to 2.23.0.v20190527-1420<\/li>\r\n\t<li>update net.bytebuddy.byte-buddy to 1.9.0.v20181107-1410<\/li>\r\n\t<li>update net.bytebuddy.byte-buddy-agent to 1.9.0.v20181106-1534<\/li>\r\n\t<li>upgrade eclipse-jarsigner-plugin to 1.1.6<\/li>\r\n\t<li>upgrade maven-javadoc-plugin to 3.1.1<\/li>\r\n\t<li>upgrade maven-site-plugin to 3.8.2<\/li>\r\n\t<li>upgrade spotbugs to 3.1.12.2<\/li>\r\n\t<li>upgrade ecj to 3.18.0<\/li>\r\n\t<li>upgrade wagon-ssh to 3.3.3<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=450485\">450485<\/a> Use https in update site URLs<\/li>\r\n\t<li>Apache HTTP: run more tests<\/li>\r\n\t<li>delete outdated Orbit target platform definitions<\/li>\r\n\t<li>add assertThrows that will be introduced in JUnit 4.13<\/li>\r\n\t<li>update bazlets to latest version<\/li>\r\n\t<li>[Java 9] Fix GitDateFormatterTest<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540790\">540790<\/a> [Java 11] Remove dependency on javax.xml.bind package<\/li>\r\n\t<li>Ignore warning that tests don&#39;t export all packages<\/li>\r\n\t<li>Ensure all packages are exported<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.5"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-18 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.5.0"}],"state":[{"value":"success"}],"title":"5.5.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.5.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.5.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.5.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-03 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a> PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\n<li>SystemReader: always return a new instance from openSystemConfig and openUserConfig<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Update bazlets to the latest master revision<\/li>\n<li>Fix generation of surefire report during site generation<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a>&nbsp;PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\r\n\t<li>SystemReader: always return a new instance from openSystemConfig and openUserConfig<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Update bazlets to the latest master revision<\/li>\r\n\t<li>Fix generation of surefire report during site generation<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.4.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.4.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-03 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a> PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\n<li>SystemReader: always return a new instance from openSystemConfig and openUserConfig<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Update bazlets to the latest master revision<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a>&nbsp;PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\r\n\t<li>SystemReader: always return a new instance from openSystemConfig and openUserConfig<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Update bazlets to the latest master revision<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.5","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-03 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a> PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\n<li>SystemReader: always return a new instance from openSystemConfig and openUserConfig<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Update bazlets to the latest master revision<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a>&nbsp;PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\r\n\t<li>SystemReader: always return a new instance from openSystemConfig and openUserConfig<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Update bazlets to the latest master revision<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.11","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.11","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-03 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a> PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\n<li>downported from stable-5.1\n<ul><li>Delete unused FileTreeIteratorWithTimeControl<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix RacyGitTests#testRacyGitDetection<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\n<\/ul><\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Update bazlets to the latest master revision<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548716\">548716<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=11373\">Gerrit 11373<\/a>&nbsp;PackedBatchRefUpdate: reproduce racy atomic update, and fix it<\/li>\r\n\t<li>downported from stable-5.1\r\n\t<ul>\r\n\t\t<li>Delete unused FileTreeIteratorWithTimeControl<\/li>\r\n\t\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a>&nbsp;Fix RacyGitTests#testRacyGitDetection<\/li>\r\n\t\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Update bazlets to the latest master revision<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.9","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.9","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-08-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features (supporting fixes)<\/h2>\n<ul><li>Cache FileStoreAttributes per directory, cache size can be configured via FileStoreAttributes#configureAttributesPathCache<\/li>\n<li>Persist minimal racy threshold and allow manual configuration\n<ul><li>Config section is \"filesystem\"<\/li>\n<li>Config subsection is concatenation of\n<ul><li>Java vendor (system property \"java.vendor\")<\/li>\n<li>Java version (system property \"java.version\")<\/li>\n<li>FileStore's name, on Windows we use the attribute volume:vsn instead since  the name is not necessarily unique.<\/li>\n<li>separated by '|'<\/li>\n<li>e.g. \"AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1\"<\/li>\n<\/ul><\/li>\n<li>The config key for minmal racy threshold is \"minRacyThreshold\" as a time value, supported time units are those supported by DefaultTypedConfigGetter#getTimeUnit<\/li>\n<li>If the minimal racy threshold is configured for a given FileStore the configured value is used instead of measuring it.<\/li>\n<li>When the minimal racy threshold was measured it is persisted in ~\/.gitconfig.<\/li>\n<\/ul><\/li>\n<li>Measure minimum racy interval to auto-configure FileSnapshot<\/li>\n<li>Measure stored file timestamp resolution instead of time to touch file<\/li>\n<li>Use Instant for smudge time in DirCache and DirCacheEntry<\/li>\n<li>Use Instant instead of milliseconds for filesystem timestamp handling This enables higher file timestamp resolution on filesystems like ext4, APFS (1ns) or NTFS (100ns) providing high timestamp resolution on filesystem level.\n<ul><li>Note: on some OSes Java 8, 9 truncate milliseconds\n<ul><li>see <a href=\"https:\/\/bugs.openjdk.java.net\/browse\/JDK-8177809\">JDK-8177809<\/a>, fixed in Java 10<\/li>\n<li>Up to Java 13 UnixFileAttributes truncate timestamp resolution to microseconds when converting the internal representation to FileTime exposed in the API, this was fixed for Java 14. See <a href=\"https:\/\/bugs.openjdk.java.net\/browse\/JDK-8181493\">JDK-8181493<\/a>.<\/li>\n<li>WindowsFileAttributes also provides only microsecond resolution, there is no fix yet hence we filed a new bug <a href=\"https:\/\/bugs.openjdk.java.net\/browse\/JDK-8231174\">JDK-8231174<\/a>.<\/li>\n<\/ul><\/li>\n<\/ul><\/li>\n<li>Add support for nanoseconds and microseconds for Config#getTimeUnit<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>, <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Persist filesystem timestamp resolution and allow manual configuration. To enable persisting filesystem timestamp resolution per FileStore add a new config section to the user global git configuration:\n<ul><li>Config section is \"filesystem\"<\/li>\n<li>Config subsection is concatenation of\n<ul><li>Java vendor (system property \"java.vendor\")<\/li>\n<li>runtime version (system property \"java.version\")<\/li>\n<li>FileStore's name<\/li>\n<li>separated by '|'<\/li>\n<li>e.g. \"AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1\"<\/li>\n<li>config key for timestamp resolution is \"timestampResolution\" as a time value, supported time units are those supported by DefaultTypedConfigGetter#getTimeUnit<\/li>\n<\/ul><\/li>\n<li>If timestamp resolution is already configured for a given FileStore the configured value is used instead of measuring the resolution.<\/li>\n<li>When timestamp resolution was measured it is persisted in ~\/.gitconfig<\/li>\n<li>Caution: do not attempt to manually configure a higher timestamp resolution than supported by the Java version being used at runtime.<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Optionally measure filesystem timestamp resolution asynchronously\n<ul><li>In order to enable measurement in the background call FileStoreAttributeCache.setAsyncfileStoreAttrCache(true)<br \/>\n\t\tbefore the first access to cached FileStore attributes.<\/li>\n<\/ul><\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li>Use AtomicReferences to cache user and system level configs<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550340\">550340<\/a> Fix copy-paste typo in CloneCommand#cleanup<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=319142\">319142<\/a> Avoid sign extension when comparing mtime with Instant#getEpochSecond<\/li>\n<li>Fix NPE in RebaseTodoFile#parseComments<\/li>\n<li>Fix NPE in ObjectIdOwnerMap#get<\/li>\n<li>Fix NPE in CommitOnlyTest#getHead<\/li>\n<li>Cache user global and system-wide git configurations in SystemReader<\/li>\n<li>Fix javadoc for SystemReader#getInstance<\/li>\n<li>Ensure tests use MockSystemReader<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544164\">544164<\/a> Make supportsAtomicCreateNewFile return true as default<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547400\">547400<\/a> Handle InvalidPathException in FS_POSIX#createNewFileAtomic<\/li>\n<li>Override FileBasedConfig's save method in MockConfig<\/li>\n<li>Fix OpenSshConfigTest#config: use FS.DETECTED instead of db.getFS()<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548947\">548947<\/a> Android: workaround SecurityException in FS#getFsTimestampResolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548682\">548682<\/a> Fix NPE in FS$FileStoreAttributeCache.getFsTimestampResolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548648\">548648<\/a> FS: ignore AccessDeniedException when measuring timestamp resolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548598\">548598<\/a> Use FileChannel.open to touch file and set mtime to now<\/li>\n<li>FileSnapshot#equals: consider UNKNOWN_SIZE<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Timeout measuring file timestamp resolution after 2 seconds<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix RacyGitTests#testRacyGitDetection<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548312\">548312<\/a> Fix non-deterministic hash of archives created by ArchiveCommand<\/li>\n<li>In LockFile#waitForStatChange wait in units of file time resolution<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>update orbit to R20190602212107-2019-06<\/li>\n<li>update dependencies\n<ul><li>com.jcraft.jsch\" version to 0.1.55.v20190404-1902<\/li>\n<li>org.apache.httpcomponents.httpclient to 4.5.6.v20190503-0009<\/li>\n<li>org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\n<li>org.mockito to 2.23.0.v20190527-1420<\/li>\n<li>org.objenesis to 2.6.0.v20180420-1519<\/li>\n<li>net.bytebuddy.byte-buddy 1.9.0.v20181107-1410<\/li>\n<li>net.bytebuddy.byte-buddy-agent 1.9.0.v20181106-1534<\/li>\n<\/ul><\/li>\n<li>pgm: add missing optional dependency to org.tukaani:xz<\/li>\n<li>update Maven pluginscleanup Maven warnings\n<ul><li>ecj to 3.17.0<\/li>\n<li>error_prone_core to 2.3.3<\/li>\n<li>jacoco-maven-plugin to 0.8.4<\/li>\n<li>japicmp-maven-plugin to 0.14.1<\/li>\n<li>maven-compiler-plugin to 3.8.1<\/li>\n<li>maven-deploy-plugin to 3.0.0-M1<\/li>\n<li>maven-enforcer-plugin to 3.0.0-M2<\/li>\n<li>maven-install-plugin to 3.0.0-M1<\/li>\n<li>maven-jar-plugin to 3.1.2<\/li>\n<li>maven-javadoc-plugin to 3.1.0<\/li>\n<li>maven-jxr-plugin to 3.0.0<\/li>\n<li>maven-pmd-plugin to 3.12.0<\/li>\n<li>maven-resources-plugin to 3.1.0<\/li>\n<li>maven-shade-plugin to 3.2.1<\/li>\n<li>maven-source-plugin to 3.1.0<\/li>\n<li>maven-surefire-plugin to 3.0.0-M3<\/li>\n<li>plexus-compiler-eclipse to 2.8.5<\/li>\n<li>plexus-compiler-javac to 2.8.5<\/li>\n<li>plexus-compiler-javac-errorprone to 2.8.5<\/li>\n<li>spotbugs-maven-plugin to 3.1.12<\/li>\n<li>tycho-extras to 1.4.0<\/li>\n<li>pin version of all used Maven plugins<\/li>\n<li>remove deprecated way to declare minimum Maven version<\/li>\n<\/ul><\/li>\n<li>Bazel\n<ul><li>Bazel: enable logging for tests in org.eclipse.jgit.test<\/li>\n<li>Increase bazel timeout for long running tests<\/li>\n<li>Bazel: Fix lint warning flagged by buildifier<\/li>\n<li>Update bazlets to latest version<\/li>\n<li>Bazel: Add missing dependencies for ArchiveCommandTest<\/li>\n<\/ul><\/li>\n<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\n<li>Reuse FileUtils to recursively delete files created by tests<\/li>\n<li>Add test for racy git detection in FileSnapshot<\/li>\n<li>Fix org.eclipse.jdt.core.prefs of org.eclipse.jgit.junit<\/li>\n<li>Enhance RepeatRule to report number of failures at the end<\/li>\n<li>Fix FileSnapshotTests for filesystem with high timestamp resolution<\/li>\n<li>Retry deleting test files in FileBasedConfigTest<\/li>\n<li>Measure filesystem timestamp resolution already in test setup<\/li>\n<li>Delete unused FileTreeIteratorWithTimeControl<\/li>\n<li>Add missing javadoc in org.eclipse.jgit.junit<\/li>\n<li>Deprecate Constants.CHARACTER_ENCODING in favor of StandardCharsets.UTF_8<\/li>\n<li>Make inner classes static where possible<\/li>\n<li>Ensure root cause of lock creation failures is logged<\/li>\n<li>Implement toString in MockSystemReader and MockConfig<\/li>\n<li>LockFile: log exception if creation of lock file failed<\/li>\n<li>Add debug trace for FileSnapshot<\/li>\n<li>Fix error prone warnings\n<ul><li>Increase severity of AmbiguousMethodReference to ERROR<\/li>\n<li>suppress AmbiguousMethodReference in AnyLongObjectId<\/li>\n<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\n<li>fix ReferenceEquality warning in CommitBuilder<\/li>\n<li>suppress NonAtomicVolatileUpdate warning in SimpleLruCache<\/li>\n<li>fix ReferenceEquality warning in CommitGraphPane#authorFor<\/li>\n<li>fix ReferenceEquality warning in RevWalk#isMergedInto<\/li>\n<li>fix ReferenceEquality warning in RefUpdate#updateImpl<\/li>\n<li>fix ReferenceEquality warning in static equals methods<\/li>\n<li>suppress AmbiguousMethodReference in AnyObjectId<\/li>\n<li>fix \"FutureReturnValueIgnored\" error in FS<\/li>\n<li>Repository: fix reference comparison of Files<\/li>\n<li>MergeAlgorithm: Suppress Error Prone warning about reference equality<\/li>\n<li>Fix NarrowingCompoundAssignment warnings from Error Prone<\/li>\n<li>GlobalBundleCache: Fix ClassNewInstance warning from Error Prone<\/li>\n<li>Increase severity of NonOverridingEquals to ERROR<\/li>\n<li>Increase severity of ImmutableEnumChecker to ERROR<\/li>\n<li>BatchRefUpdateTest: Suppress ImmutableEnumChecker warning<\/li>\n<li>PacketLineIn: Suppress comparison warnings for END and DELIM<\/li>\n<li>FileSnapshot#toString: Suppress ReferenceEquality warnings<\/li>\n<li>Blame: Suppress ReferenceEquality warning for RevCommit instances<\/li>\n<li>NetscapeCookieFile: Make hash static and group overloaded write<\/li>\n<li>NetscapeCookieFile: Javadoc fixes<\/li>\n<li>Config: Handle reference-equality warning (and empty javadoc)<\/li>\n<li>Increase severity of ShortCircuitBoolean to ERROR<\/li>\n<li>ObjectWalk: Prefer boolean operators over logical operators in comparisons<\/li>\n<li>BasePackFetchConnection: Prefer boolean operators over logical operators in comparisons<\/li>\n<li>PackWriter: Prefer boolean operators over logical operators in comparisons<\/li>\n<\/ul><\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Features (supporting fixes)<\/h2>\r\n\r\n<ul>\r\n\t<li>Cache FileStoreAttributes per directory, cache size can be configured via FileStoreAttributes#configureAttributesPathCache<\/li>\r\n\t<li>Persist minimal racy threshold and allow manual configuration\r\n\t<ul>\r\n\t\t<li>Config section is &quot;filesystem&quot;<\/li>\r\n\t\t<li>Config subsection is concatenation of\r\n\t\t<ul>\r\n\t\t\t<li>Java vendor (system property &quot;java.vendor&quot;)<\/li>\r\n\t\t\t<li>Java version (system property &quot;java.version&quot;)<\/li>\r\n\t\t\t<li>FileStore&#39;s name, on Windows we use the attribute volume:vsn instead since &nbsp;the name is not necessarily unique.<\/li>\r\n\t\t\t<li>separated by &#39;|&#39;<\/li>\r\n\t\t\t<li>e.g. &quot;AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1&quot;<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>The config key for minmal racy threshold is &quot;minRacyThreshold&quot; as a time value, supported time units are those supported by&nbsp;DefaultTypedConfigGetter#getTimeUnit<\/li>\r\n\t\t<li>If the minimal racy threshold is configured for a given FileStore the configured value is used instead of measuring it.<\/li>\r\n\t\t<li>When the minimal racy threshold was measured it is persisted in ~\/.gitconfig.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Measure minimum racy interval to auto-configure FileSnapshot<\/li>\r\n\t<li>Measure stored file timestamp resolution instead of time to touch file<\/li>\r\n\t<li>Use Instant for smudge time in DirCache and DirCacheEntry<\/li>\r\n\t<li>Use Instant instead of milliseconds for filesystem timestamp handling This enables higher file timestamp resolution on filesystems like ext4, APFS (1ns) or NTFS (100ns) providing high timestamp resolution on filesystem level.\r\n\t<ul>\r\n\t\t<li>Note: on some OSes Java 8, 9 truncate milliseconds\r\n\t\t<ul>\r\n\t\t\t<li>see <a href=\"https:\/\/bugs.openjdk.java.net\/browse\/JDK-8177809\">JDK-8177809<\/a>, fixed in Java 10<\/li>\r\n\t\t\t<li>Up to Java 13 UnixFileAttributes truncate&nbsp;timestamp resolution to microseconds when converting the internal representation to FileTime exposed in the API,&nbsp;this was fixed for Java 14.&nbsp;See <a href=\"https:\/\/bugs.openjdk.java.net\/browse\/JDK-8181493\">JDK-8181493<\/a>.<\/li>\r\n\t\t\t<li>WindowsFileAttributes also provides only microsecond resolution, there is no fix yet hence we filed a new bug <a href=\"https:\/\/bugs.openjdk.java.net\/browse\/JDK-8231174\">JDK-8231174<\/a>.<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Add support for nanoseconds and microseconds for Config#getTimeUnit<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>, <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Persist filesystem timestamp resolution and allow manual configuration. To enable persisting filesystem timestamp resolution per FileStore add a new config section to the user global git configuration:\r\n\t<ul>\r\n\t\t<li>Config section is &quot;filesystem&quot;<\/li>\r\n\t\t<li>Config subsection is concatenation of\r\n\t\t<ul>\r\n\t\t\t<li>Java vendor (system property &quot;java.vendor&quot;)<\/li>\r\n\t\t\t<li>runtime version (system property &quot;java.version&quot;)<\/li>\r\n\t\t\t<li>FileStore&#39;s name<\/li>\r\n\t\t\t<li>separated by &#39;|&#39;<\/li>\r\n\t\t\t<li>e.g.&nbsp;&quot;AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1&quot;<\/li>\r\n\t\t\t<li>config key for timestamp resolution is &quot;timestampResolution&quot; as a time value, supported time units are those supported by&nbsp;DefaultTypedConfigGetter#getTimeUnit<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>If timestamp resolution is already configured for a given FileStore the configured value is used instead of measuring the resolution.<\/li>\r\n\t\t<li>When timestamp resolution was measured it is persisted in ~\/.gitconfig<\/li>\r\n\t\t<li>Caution: do not attempt to manually configure a higher timestamp resolution than supported by the Java version being used at runtime.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Optionally measure filesystem timestamp resolution asynchronously\r\n\t<ul>\r\n\t\t<li>In order to enable measurement in the background call FileStoreAttributeCache.setAsyncfileStoreAttrCache(true)<br \/>\r\n\t\tbefore the first access to cached FileStore attributes.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Use AtomicReferences to cache user and system level configs<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550340\">550340<\/a>&nbsp;Fix copy-paste typo in CloneCommand#cleanup<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=319142\">319142<\/a> Avoid sign extension when comparing mtime with Instant#getEpochSecond<\/li>\r\n\t<li>Fix NPE in RebaseTodoFile#parseComments<\/li>\r\n\t<li>Fix NPE in ObjectIdOwnerMap#get<\/li>\r\n\t<li>Fix NPE in CommitOnlyTest#getHead<\/li>\r\n\t<li>Cache user global and system-wide git configurations in SystemReader<\/li>\r\n\t<li>Fix javadoc for SystemReader#getInstance<\/li>\r\n\t<li>Ensure tests use MockSystemReader<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544164\">544164<\/a> Make supportsAtomicCreateNewFile return true as default<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547400\">547400<\/a> Handle InvalidPathException in FS_POSIX#createNewFileAtomic<\/li>\r\n\t<li>Override FileBasedConfig&#39;s save method in MockConfig<\/li>\r\n\t<li>Fix OpenSshConfigTest#config: use FS.DETECTED instead of db.getFS()<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548947\">548947<\/a> Android: workaround SecurityException in FS#getFsTimestampResolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548682\">548682<\/a> Fix NPE in FS$FileStoreAttributeCache.getFsTimestampResolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548648\">548648<\/a> FS: ignore AccessDeniedException when measuring timestamp resolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548598\">548598<\/a> Use FileChannel.open to touch file and set mtime to now<\/li>\r\n\t<li>FileSnapshot#equals: consider UNKNOWN_SIZE<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Timeout measuring file timestamp resolution after 2 seconds<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix RacyGitTests#testRacyGitDetection<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548312\">548312<\/a> Fix non-deterministic hash of archives created by ArchiveCommand<\/li>\r\n\t<li>In LockFile#waitForStatChange wait in units of file time resolution<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>update orbit to R20190602212107-2019-06<\/li>\r\n\t<li>update dependencies\r\n\t<ul>\r\n\t\t<li>com.jcraft.jsch&quot; version to 0.1.55.v20190404-1902<\/li>\r\n\t\t<li>org.apache.httpcomponents.httpclient to 4.5.6.v20190503-0009<\/li>\r\n\t\t<li>org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\r\n\t\t<li>org.mockito to 2.23.0.v20190527-1420<\/li>\r\n\t\t<li>org.objenesis to 2.6.0.v20180420-1519<\/li>\r\n\t\t<li>net.bytebuddy.byte-buddy 1.9.0.v20181107-1410<\/li>\r\n\t\t<li>net.bytebuddy.byte-buddy-agent 1.9.0.v20181106-1534<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>pgm: add missing optional dependency to org.tukaani:xz<\/li>\r\n\t<li>update Maven pluginscleanup Maven warnings\r\n\t<ul>\r\n\t\t<li>ecj to 3.17.0<\/li>\r\n\t\t<li>error_prone_core to 2.3.3<\/li>\r\n\t\t<li>jacoco-maven-plugin to 0.8.4<\/li>\r\n\t\t<li>japicmp-maven-plugin to 0.14.1<\/li>\r\n\t\t<li>maven-compiler-plugin to 3.8.1<\/li>\r\n\t\t<li>maven-deploy-plugin to 3.0.0-M1<\/li>\r\n\t\t<li>maven-enforcer-plugin to 3.0.0-M2<\/li>\r\n\t\t<li>maven-install-plugin to 3.0.0-M1<\/li>\r\n\t\t<li>maven-jar-plugin to 3.1.2<\/li>\r\n\t\t<li>maven-javadoc-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-jxr-plugin to 3.0.0<\/li>\r\n\t\t<li>maven-pmd-plugin to 3.12.0<\/li>\r\n\t\t<li>maven-resources-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-shade-plugin to 3.2.1<\/li>\r\n\t\t<li>maven-source-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-surefire-plugin to 3.0.0-M3<\/li>\r\n\t\t<li>plexus-compiler-eclipse to 2.8.5<\/li>\r\n\t\t<li>plexus-compiler-javac to 2.8.5<\/li>\r\n\t\t<li>plexus-compiler-javac-errorprone to 2.8.5<\/li>\r\n\t\t<li>spotbugs-maven-plugin to 3.1.12<\/li>\r\n\t\t<li>tycho-extras to 1.4.0<\/li>\r\n\t\t<li>pin version of all used Maven plugins<\/li>\r\n\t\t<li>remove deprecated way to declare minimum Maven version<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Bazel\r\n\t<ul>\r\n\t\t<li>Bazel: enable logging for tests in org.eclipse.jgit.test<\/li>\r\n\t\t<li>Increase bazel timeout for long running tests<\/li>\r\n\t\t<li>Bazel: Fix lint warning flagged by buildifier<\/li>\r\n\t\t<li>Update bazlets to latest version<\/li>\r\n\t\t<li>Bazel: Add missing dependencies for ArchiveCommandTest<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\r\n\t<li>Reuse FileUtils to recursively delete files created by tests<\/li>\r\n\t<li>Add test for racy git detection in FileSnapshot<\/li>\r\n\t<li>Fix org.eclipse.jdt.core.prefs of org.eclipse.jgit.junit<\/li>\r\n\t<li>Enhance RepeatRule to report number of failures at the end<\/li>\r\n\t<li>Fix FileSnapshotTests for filesystem with high timestamp resolution<\/li>\r\n\t<li>Retry deleting test files in FileBasedConfigTest<\/li>\r\n\t<li>Measure filesystem timestamp resolution already in test setup<\/li>\r\n\t<li>Delete unused FileTreeIteratorWithTimeControl<\/li>\r\n\t<li>Add missing javadoc in org.eclipse.jgit.junit<\/li>\r\n\t<li>Deprecate Constants.CHARACTER_ENCODING in favor of StandardCharsets.UTF_8<\/li>\r\n\t<li>Make inner classes static where possible<\/li>\r\n\t<li>Ensure root cause of lock creation failures is logged<\/li>\r\n\t<li>Implement toString in MockSystemReader and MockConfig<\/li>\r\n\t<li>LockFile: log exception if creation of lock file failed<\/li>\r\n\t<li>Add debug trace for FileSnapshot<\/li>\r\n\t<li>Fix error prone warnings\r\n\t<ul>\r\n\t\t<li>Increase severity of AmbiguousMethodReference to ERROR<\/li>\r\n\t\t<li>suppress AmbiguousMethodReference in AnyLongObjectId<\/li>\r\n\t\t<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\r\n\t\t<li>fix ReferenceEquality warning in CommitBuilder<\/li>\r\n\t\t<li>suppress NonAtomicVolatileUpdate warning in SimpleLruCache<\/li>\r\n\t\t<li>fix ReferenceEquality warning in CommitGraphPane#authorFor<\/li>\r\n\t\t<li>fix ReferenceEquality warning in RevWalk#isMergedInto<\/li>\r\n\t\t<li>fix ReferenceEquality warning in RefUpdate#updateImpl<\/li>\r\n\t\t<li>fix ReferenceEquality warning in static equals methods<\/li>\r\n\t\t<li>suppress AmbiguousMethodReference in AnyObjectId<\/li>\r\n\t\t<li>fix &quot;FutureReturnValueIgnored&quot; error in FS<\/li>\r\n\t\t<li>Repository: fix reference comparison of Files<\/li>\r\n\t\t<li>MergeAlgorithm: Suppress Error Prone warning about reference equality<\/li>\r\n\t\t<li>Fix NarrowingCompoundAssignment warnings from Error Prone<\/li>\r\n\t\t<li>GlobalBundleCache: Fix ClassNewInstance warning from Error Prone<\/li>\r\n\t\t<li>Increase severity of NonOverridingEquals to ERROR<\/li>\r\n\t\t<li>Increase severity of ImmutableEnumChecker to ERROR<\/li>\r\n\t\t<li>BatchRefUpdateTest: Suppress ImmutableEnumChecker warning<\/li>\r\n\t\t<li>PacketLineIn: Suppress comparison warnings for END and DELIM<\/li>\r\n\t\t<li>FileSnapshot#toString: Suppress ReferenceEquality warnings<\/li>\r\n\t\t<li>Blame: Suppress ReferenceEquality warning for RevCommit instances<\/li>\r\n\t\t<li>NetscapeCookieFile: Make hash static and group overloaded write<\/li>\r\n\t\t<li>NetscapeCookieFile: Javadoc fixes<\/li>\r\n\t\t<li>Config: Handle reference-equality warning (and empty javadoc)<\/li>\r\n\t\t<li>Increase severity of ShortCircuitBoolean to ERROR<\/li>\r\n\t\t<li>ObjectWalk: Prefer boolean operators over logical operators in comparisons<\/li>\r\n\t\t<li>BasePackFetchConnection: Prefer boolean operators over logical operators in comparisons<\/li>\r\n\t\t<li>PackWriter: Prefer boolean operators over logical operators in comparisons<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.4.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.4.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-08-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features (supporting fixes)<\/h2>\n<ul><li>Cache FileStoreAttributes per directory, cache size can be configured via FileStoreAttributes#configureAttributesPathCache<\/li>\n<li>Persist minimal racy threshold and allow manual configuration\n<ul><li>Config section is \"filesystem\"<\/li>\n<li>Config subsection is concatenation of\n<ul><li>Java vendor (system property \"java.vendor\")<\/li>\n<li>Java version (system property \"java.version\")<\/li>\n<li>FileStore's name, on Windows we use the attribute volume:vsn instead since  the name is not necessarily unique.<\/li>\n<li>separated by '|'<\/li>\n<li>e.g. \"AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1\"<\/li>\n<\/ul><\/li>\n<li>The config key for minmal racy threshold is \"minRacyThreshold\" as a time value, supported time units are those supported by DefaultTypedConfigGetter#getTimeUnit<\/li>\n<li>If the minimal racy threshold is configured for a given FileStore the configured value is used instead of measuring it.<\/li>\n<li>When the minimal racy threshold was measured it is persisted in ~\/.gitconfig.<\/li>\n<\/ul><\/li>\n<li>Measure minimum racy interval to auto-configure FileSnapshot<\/li>\n<li>Measure stored file timestamp resolution instead of time to touch file<\/li>\n<li>Use Instant for smudge time in DirCache and DirCacheEntry<\/li>\n<li>Use Instant instead of milliseconds for filesystem timestamp handling This enables higher file timestamp resolution on filesystems like ext4, APFS (1ns) or NTFS (100ns) providing high timestamp resolution on filesystem level.\n<ul><li>Note: on some OSes Java 8, 9 truncate milliseconds\n<ul><li>see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8177809, fixed in Java 10<\/li>\n<li>UnixFileAttributes truncates timestamp resolution to microseconds when converting the internal representation to FileTime exposed in the API, see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8181493<\/li>\n<li>WindowsFileAttributes also provides only microsecond resolution<\/li>\n<\/ul><\/li>\n<\/ul><\/li>\n<li>Add support for nanoseconds and microseconds for Config#getTimeUnit<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>, <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Persist filesystem timestamp resolution and allow manual configuration. To enable persisting filesystem timestamp resolution per FileStore add a new config section to the user global git configuration:\n<ul><li>Config section is \"filesystem\"<\/li>\n<li>Config subsection is concatenation of\n<ul><li>Java vendor (system property \"java.vendor\")<\/li>\n<li>runtime version (system property \"java.version\")<\/li>\n<li>FileStore's name<\/li>\n<li>separated by '|'<\/li>\n<li>e.g. \"AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1\"<\/li>\n<li>config key for timestamp resolution is \"timestampResolution\" as a time value, supported time units are those supported by DefaultTypedConfigGetter#getTimeUnit<\/li>\n<\/ul><\/li>\n<li>If timestamp resolution is already configured for a given FileStore the configured value is used instead of measuring the resolution.<\/li>\n<li>When timestamp resolution was measured it is persisted in ~\/.gitconfig<\/li>\n<li>Caution: do not attempt to manually configure a higher timestamp resolution than supported by the Java version being used at runtime.<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Optionally measure filesystem timestamp resolution asynchronously\n<ul><li>In order to enable measurement in the background call FileStoreAttributeCache.setAsyncfileStoreAttrCache(true)<br \/>\n\t\tbefore the first access to cached FileStore attributes.<\/li>\n<\/ul><\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li>Use AtomicReferences to cache user and system level configs<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550340\">550340<\/a> Fix copy-paste typo in CloneCommand#cleanup<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=319142\">319142<\/a> Avoid sign extension when comparing mtime with Instant#getEpochSecond<\/li>\n<li>Fix NPE in RebaseTodoFile#parseComments<\/li>\n<li>Fix NPE in ObjectIdOwnerMap#get<\/li>\n<li>Fix NPE in CommitOnlyTest#getHead<\/li>\n<li>Cache user global and system-wide git configurations in SystemReader<\/li>\n<li>Fix javadoc for SystemReader#getInstance<\/li>\n<li>Ensure tests use MockSystemReader<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544164\">544164<\/a> Make supportsAtomicCreateNewFile return true as default<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547400\">547400<\/a> Handle InvalidPathException in FS_POSIX#createNewFileAtomic<\/li>\n<li>Override FileBasedConfig's save method in MockConfig<\/li>\n<li>Fix OpenSshConfigTest#config: use FS.DETECTED instead of db.getFS()<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548947\">548947<\/a> Android: workaround SecurityException in FS#getFsTimestampResolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548682\">548682<\/a> Fix NPE in FS$FileStoreAttributeCache.getFsTimestampResolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548648\">548648<\/a> FS: ignore AccessDeniedException when measuring timestamp resolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548598\">548598<\/a> Use FileChannel.open to touch file and set mtime to now<\/li>\n<li>FileSnapshot#equals: consider UNKNOWN_SIZE<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Timeout measuring file timestamp resolution after 2 seconds<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix RacyGitTests#testRacyGitDetection<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548312\">548312<\/a> Fix non-deterministic hash of archives created by ArchiveCommand<\/li>\n<li>In LockFile#waitForStatChange wait in units of file time resolution<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>update orbit to R20190602212107-2019-06<\/li>\n<li>update dependencies\n<ul><li>com.jcraft.jsch\" version to 0.1.55.v20190404-1902<\/li>\n<li>org.apache.httpcomponents.httpclient to 4.5.6.v20190503-0009<\/li>\n<li>org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\n<li>org.mockito to 2.23.0.v20190527-1420<\/li>\n<li>org.objenesis to 2.6.0.v20180420-1519<\/li>\n<li>net.bytebuddy.byte-buddy 1.9.0.v20181107-1410<\/li>\n<li>net.bytebuddy.byte-buddy-agent 1.9.0.v20181106-1534<\/li>\n<\/ul><\/li>\n<li>update Maven plugins\n<ul><li>ecj to 3.17.0<\/li>\n<li>error_prone_core to 2.3.3<\/li>\n<li>jacoco-maven-plugin to 0.8.4<\/li>\n<li>japicmp-maven-plugin to 0.14.1<\/li>\n<li>maven-compiler-plugin to 3.8.1<\/li>\n<li>maven-deploy-plugin to 3.0.0-M1<\/li>\n<li>maven-enforcer-plugin to 3.0.0-M2<\/li>\n<li>maven-install-plugin to 3.0.0-M1<\/li>\n<li>maven-jar-plugin to 3.1.2<\/li>\n<li>maven-javadoc-plugin to 3.1.0<\/li>\n<li>maven-jxr-plugin to 3.0.0<\/li>\n<li>maven-pmd-plugin to 3.12.0<\/li>\n<li>maven-resources-plugin to 3.1.0<\/li>\n<li>maven-shade-plugin to 3.2.1<\/li>\n<li>maven-source-plugin to 3.1.0<\/li>\n<li>maven-surefire-plugin to 3.0.0-M3<\/li>\n<li>plexus-compiler-eclipse to 2.8.5<\/li>\n<li>plexus-compiler-javac to 2.8.5<\/li>\n<li>plexus-compiler-javac-errorprone to 2.8.5<\/li>\n<li>spotbugs-maven-plugin to 3.1.12<\/li>\n<li>tycho to 1.3.0<\/li>\n<li>tycho-pack200a-plugin to 1.3.0<\/li>\n<li>tycho-pack200b-plugin to 1.3.0<\/li>\n<\/ul><\/li>\n<li>cleanup Maven warnings\n<ul><li>pin version of all used Maven plugins<\/li>\n<li>remove deprecated way to declare minimum Maven version<\/li>\n<\/ul><\/li>\n<li>Bazel\n<ul><li>Bazel: enable logging for tests in org.eclipse.jgit.test<\/li>\n<li>Increase bazel timeout for long running tests<\/li>\n<li>Bazel: Fix lint warning flagged by buildifier<\/li>\n<li>Update bazlets to latest version<\/li>\n<li>Bazel: Add missing dependencies for ArchiveCommandTest<\/li>\n<\/ul><\/li>\n<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\n<li>Reuse FileUtils to recursively delete files created by tests<\/li>\n<li>Add test for racy git detection in FileSnapshot<\/li>\n<li>Fix org.eclipse.jdt.core.prefs of org.eclipse.jgit.junit<\/li>\n<li>Enhance RepeatRule to report number of failures at the end<\/li>\n<li>Fix FileSnapshotTests for filesystem with high timestamp resolution<\/li>\n<li>Retry deleting test files in FileBasedConfigTest<\/li>\n<li>Measure filesystem timestamp resolution already in test setup<\/li>\n<li>Delete unused FileTreeIteratorWithTimeControl<\/li>\n<li>Add missing javadoc in org.eclipse.jgit.junit<\/li>\n<li>Deprecate Constants.CHARACTER_ENCODING in favor of StandardCharsets.UTF_8<\/li>\n<li>Make inner classes static where possible<\/li>\n<li>Ensure root cause of lock creation failures is logged<\/li>\n<li>Implement toString in MockSystemReader and MockConfig<\/li>\n<li>LockFile: log exception if creation of lock file failed<\/li>\n<li>Add debug trace for FileSnapshot<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Features (supporting fixes)<\/h2>\r\n\r\n<ul>\r\n\t<li>Cache FileStoreAttributes per directory, cache size can be configured via FileStoreAttributes#configureAttributesPathCache<\/li>\r\n\t<li>Persist minimal racy threshold and allow manual configuration\r\n\t<ul>\r\n\t\t<li>Config section is &quot;filesystem&quot;<\/li>\r\n\t\t<li>Config subsection is concatenation of\r\n\t\t<ul>\r\n\t\t\t<li>Java vendor (system property &quot;java.vendor&quot;)<\/li>\r\n\t\t\t<li>Java version (system property &quot;java.version&quot;)<\/li>\r\n\t\t\t<li>FileStore&#39;s name, on Windows we use the attribute volume:vsn instead since &nbsp;the name is not necessarily unique.<\/li>\r\n\t\t\t<li>separated by &#39;|&#39;<\/li>\r\n\t\t\t<li>e.g. &quot;AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1&quot;<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>The config key for minmal racy threshold is &quot;minRacyThreshold&quot; as a time value, supported time units are those supported by&nbsp;DefaultTypedConfigGetter#getTimeUnit<\/li>\r\n\t\t<li>If the minimal racy threshold is configured for a given FileStore the configured value is used instead of measuring it.<\/li>\r\n\t\t<li>When the minimal racy threshold was measured it is persisted in ~\/.gitconfig.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Measure minimum racy interval to auto-configure FileSnapshot<\/li>\r\n\t<li>Measure stored file timestamp resolution instead of time to touch file<\/li>\r\n\t<li>Use Instant for smudge time in DirCache and DirCacheEntry<\/li>\r\n\t<li>Use Instant instead of milliseconds for filesystem timestamp handling This enables higher file timestamp resolution on filesystems like ext4, APFS (1ns) or NTFS (100ns) providing high timestamp resolution on filesystem level.\r\n\t<ul>\r\n\t\t<li>Note: on some OSes Java 8, 9 truncate milliseconds\r\n\t\t<ul>\r\n\t\t\t<li>see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8177809, fixed in Java 10<\/li>\r\n\t\t\t<li>UnixFileAttributes truncates timestamp resolution to microseconds when converting the internal representation to FileTime exposed in the API,&nbsp;see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8181493<\/li>\r\n\t\t\t<li>WindowsFileAttributes also provides only microsecond resolution<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Add support for nanoseconds and microseconds for Config#getTimeUnit<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>, <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Persist filesystem timestamp resolution and allow manual configuration. To enable persisting filesystem timestamp resolution per FileStore add a new config section to the user global git configuration:\r\n\t<ul>\r\n\t\t<li>Config section is &quot;filesystem&quot;<\/li>\r\n\t\t<li>Config subsection is concatenation of\r\n\t\t<ul>\r\n\t\t\t<li>Java vendor (system property &quot;java.vendor&quot;)<\/li>\r\n\t\t\t<li>runtime version (system property &quot;java.version&quot;)<\/li>\r\n\t\t\t<li>FileStore&#39;s name<\/li>\r\n\t\t\t<li>separated by &#39;|&#39;<\/li>\r\n\t\t\t<li>e.g.&nbsp;&quot;AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1&quot;<\/li>\r\n\t\t\t<li>config key for timestamp resolution is &quot;timestampResolution&quot; as a time value, supported time units are those supported by&nbsp;DefaultTypedConfigGetter#getTimeUnit<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>If timestamp resolution is already configured for a given FileStore the configured value is used instead of measuring the resolution.<\/li>\r\n\t\t<li>When timestamp resolution was measured it is persisted in ~\/.gitconfig<\/li>\r\n\t\t<li>Caution: do not attempt to manually configure a higher timestamp resolution than supported by the Java version being used at runtime.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Optionally measure filesystem timestamp resolution asynchronously\r\n\t<ul>\r\n\t\t<li>In order to enable measurement in the background call FileStoreAttributeCache.setAsyncfileStoreAttrCache(true)<br \/>\r\n\t\tbefore the first access to cached FileStore attributes.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Use AtomicReferences to cache user and system level configs<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550340\">550340<\/a>&nbsp;Fix copy-paste typo in CloneCommand#cleanup<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=319142\">319142<\/a> Avoid sign extension when comparing mtime with Instant#getEpochSecond<\/li>\r\n\t<li>Fix NPE in RebaseTodoFile#parseComments<\/li>\r\n\t<li>Fix NPE in ObjectIdOwnerMap#get<\/li>\r\n\t<li>Fix NPE in CommitOnlyTest#getHead<\/li>\r\n\t<li>Cache user global and system-wide git configurations in SystemReader<\/li>\r\n\t<li>Fix javadoc for SystemReader#getInstance<\/li>\r\n\t<li>Ensure tests use MockSystemReader<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544164\">544164<\/a> Make supportsAtomicCreateNewFile return true as default<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547400\">547400<\/a> Handle InvalidPathException in FS_POSIX#createNewFileAtomic<\/li>\r\n\t<li>Override FileBasedConfig&#39;s save method in MockConfig<\/li>\r\n\t<li>Fix OpenSshConfigTest#config: use FS.DETECTED instead of db.getFS()<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548947\">548947<\/a> Android: workaround SecurityException in FS#getFsTimestampResolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548682\">548682<\/a> Fix NPE in FS$FileStoreAttributeCache.getFsTimestampResolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548648\">548648<\/a> FS: ignore AccessDeniedException when measuring timestamp resolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548598\">548598<\/a> Use FileChannel.open to touch file and set mtime to now<\/li>\r\n\t<li>FileSnapshot#equals: consider UNKNOWN_SIZE<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Timeout measuring file timestamp resolution after 2 seconds<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix RacyGitTests#testRacyGitDetection<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548312\">548312<\/a> Fix non-deterministic hash of archives created by ArchiveCommand<\/li>\r\n\t<li>In LockFile#waitForStatChange wait in units of file time resolution<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>update orbit to R20190602212107-2019-06<\/li>\r\n\t<li>update dependencies\r\n\t<ul>\r\n\t\t<li>com.jcraft.jsch&quot; version to 0.1.55.v20190404-1902<\/li>\r\n\t\t<li>org.apache.httpcomponents.httpclient to 4.5.6.v20190503-0009<\/li>\r\n\t\t<li>org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\r\n\t\t<li>org.mockito to 2.23.0.v20190527-1420<\/li>\r\n\t\t<li>org.objenesis to 2.6.0.v20180420-1519<\/li>\r\n\t\t<li>net.bytebuddy.byte-buddy 1.9.0.v20181107-1410<\/li>\r\n\t\t<li>net.bytebuddy.byte-buddy-agent 1.9.0.v20181106-1534<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>update Maven plugins\r\n\t<ul>\r\n\t\t<li>ecj to 3.17.0<\/li>\r\n\t\t<li>error_prone_core to 2.3.3<\/li>\r\n\t\t<li>jacoco-maven-plugin to 0.8.4<\/li>\r\n\t\t<li>japicmp-maven-plugin to 0.14.1<\/li>\r\n\t\t<li>maven-compiler-plugin to 3.8.1<\/li>\r\n\t\t<li>maven-deploy-plugin to 3.0.0-M1<\/li>\r\n\t\t<li>maven-enforcer-plugin to 3.0.0-M2<\/li>\r\n\t\t<li>maven-install-plugin to 3.0.0-M1<\/li>\r\n\t\t<li>maven-jar-plugin to 3.1.2<\/li>\r\n\t\t<li>maven-javadoc-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-jxr-plugin to 3.0.0<\/li>\r\n\t\t<li>maven-pmd-plugin to 3.12.0<\/li>\r\n\t\t<li>maven-resources-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-shade-plugin to 3.2.1<\/li>\r\n\t\t<li>maven-source-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-surefire-plugin to 3.0.0-M3<\/li>\r\n\t\t<li>plexus-compiler-eclipse to 2.8.5<\/li>\r\n\t\t<li>plexus-compiler-javac to 2.8.5<\/li>\r\n\t\t<li>plexus-compiler-javac-errorprone to 2.8.5<\/li>\r\n\t\t<li>spotbugs-maven-plugin to 3.1.12<\/li>\r\n\t\t<li>tycho to 1.3.0<\/li>\r\n\t\t<li>tycho-pack200a-plugin to 1.3.0<\/li>\r\n\t\t<li>tycho-pack200b-plugin to 1.3.0<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>cleanup Maven warnings\r\n\t<ul>\r\n\t\t<li>pin version of all used Maven plugins<\/li>\r\n\t\t<li>remove deprecated way to declare minimum Maven version<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Bazel\r\n\t<ul>\r\n\t\t<li>Bazel: enable logging for tests in org.eclipse.jgit.test<\/li>\r\n\t\t<li>Increase bazel timeout for long running tests<\/li>\r\n\t\t<li>Bazel: Fix lint warning flagged by buildifier<\/li>\r\n\t\t<li>Update bazlets to latest version<\/li>\r\n\t\t<li>Bazel: Add missing dependencies for ArchiveCommandTest<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\r\n\t<li>Reuse FileUtils to recursively delete files created by tests<\/li>\r\n\t<li>Add test for racy git detection in FileSnapshot<\/li>\r\n\t<li>Fix org.eclipse.jdt.core.prefs of org.eclipse.jgit.junit<\/li>\r\n\t<li>Enhance RepeatRule to report number of failures at the end<\/li>\r\n\t<li>Fix FileSnapshotTests for filesystem with high timestamp resolution<\/li>\r\n\t<li>Retry deleting test files in FileBasedConfigTest<\/li>\r\n\t<li>Measure filesystem timestamp resolution already in test setup<\/li>\r\n\t<li>Delete unused FileTreeIteratorWithTimeControl<\/li>\r\n\t<li>Add missing javadoc in org.eclipse.jgit.junit<\/li>\r\n\t<li>Deprecate Constants.CHARACTER_ENCODING in favor of StandardCharsets.UTF_8<\/li>\r\n\t<li>Make inner classes static where possible<\/li>\r\n\t<li>Ensure root cause of lock creation failures is logged<\/li>\r\n\t<li>Implement toString in MockSystemReader and MockConfig<\/li>\r\n\t<li>LockFile: log exception if creation of lock file failed<\/li>\r\n\t<li>Add debug trace for FileSnapshot<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.4","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.4","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-08-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>Use AtomicReferences to cache user and system level configs<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550340\">550340<\/a> Fix copy-paste typo in CloneCommand#cleanup<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Use AtomicReferences to cache user and system level configs<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=550340\">550340<\/a> Fix copy-paste typo in CloneCommand#cleanup<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.10","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.10","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-08-21 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features (supporting fixes)<\/h2>\n<ul><li>Cache FileStoreAttributes per directory, cache size can be configured via FileStoreAttributes#configureAttributesPathCache<\/li>\n<li>Persist minimal racy threshold and allow manual configuration\n<ul><li>Config section is \"filesystem\"<\/li>\n<li>Config subsection is concatenation of\n<ul><li>Java vendor (system property \"java.vendor\")<\/li>\n<li>Java version (system property \"java.version\")<\/li>\n<li>FileStore's name, on Windows we use the attribute volume:vsn instead since  the name is not necessarily unique.<\/li>\n<li>separated by '|'<\/li>\n<li>e.g. \"AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1\"<\/li>\n<\/ul><\/li>\n<li>The config key for minmal racy threshold is \"minRacyThreshold\" as a time value, supported time units are those supported by DefaultTypedConfigGetter#getTimeUnit<\/li>\n<li>If the minimal racy threshold is configured for a given FileStore the configured value is used instead of measuring it.<\/li>\n<li>When the minimal racy threshold was measured it is persisted in ~\/.gitconfig.<\/li>\n<\/ul><\/li>\n<li>Measure minimum racy interval to auto-configure FileSnapshot<\/li>\n<li>Measure stored file timestamp resolution instead of time to touch file<\/li>\n<li>Use Instant for smudge time in DirCache and DirCacheEntry<\/li>\n<li>Use Instant instead of milliseconds for filesystem timestamp handling This enables higher file timestamp resolution on filesystems like ext4, APFS (1ns) or NTFS (100ns) providing high timestamp resolution on filesystem level.\n<ul><li>Note: on some OSes Java 8, 9 truncate milliseconds\n<ul><li>see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8177809, fixed in Java 10<\/li>\n<li>UnixFileAttributes truncates timestamp resolution to microseconds when converting the internal representation to FileTime exposed in the API, see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8181493<\/li>\n<li>WindowsFileAttributes also provides only microsecond resolution<\/li>\n<\/ul><\/li>\n<\/ul><\/li>\n<li>Add support for nanoseconds and microseconds for Config#getTimeUnit<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>, <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Persist filesystem timestamp resolution and allow manual configuration. To enable persisting filesystem timestamp resolution per FileStore add a new config section to the user global git configuration:\n<ul><li>Config section is \"filesystem\"<\/li>\n<li>Config subsection is concatenation of\n<ul><li>Java vendor (system property \"java.vendor\")<\/li>\n<li>runtime version (system property \"java.version\")<\/li>\n<li>FileStore's name<\/li>\n<li>separated by '|'<\/li>\n<li>e.g. \"AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1\"<\/li>\n<li>config key for timestamp resolution is \"timestampResolution\" as a time value, supported time units are those supported by DefaultTypedConfigGetter#getTimeUnit<\/li>\n<\/ul><\/li>\n<li>If timestamp resolution is already configured for a given FileStore the configured value is used instead of measuring the resolution.<\/li>\n<li>When timestamp resolution was measured it is persisted in ~\/.gitconfig<\/li>\n<li>Caution: do not attempt to manually configure a higher timestamp resolution than supported by the Java version being used at runtime.<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Optionally measure filesystem timestamp resolution asynchronously\n<ul><li>In order to enable measurement in the background call FileStoreAttributeCache.setAsyncfileStoreAttrCache(true)<br \/>\n\t\tbefore the first access to cached FileStore attributes.<\/li>\n<\/ul><\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=319142\">319142<\/a> Avoid sign extension when comparing mtime with Instant#getEpochSecond<\/li>\n<li>Fix NPE in RebaseTodoFile#parseComments<\/li>\n<li>Fix NPE in ObjectIdOwnerMap#get<\/li>\n<li>Fix NPE in CommitOnlyTest#getHead<\/li>\n<li>Cache user global and system-wide git configurations in SystemReader<\/li>\n<li>Fix javadoc for SystemReader#getInstance<\/li>\n<li>Ensure tests use MockSystemReader<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544164\">544164<\/a> Make supportsAtomicCreateNewFile return true as default<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547400\">547400<\/a> Handle InvalidPathException in FS_POSIX#createNewFileAtomic<\/li>\n<li>Override FileBasedConfig's save method in MockConfig<\/li>\n<li>Fix OpenSshConfigTest#config: use FS.DETECTED instead of db.getFS()<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548947\">548947<\/a> Android: workaround SecurityException in FS#getFsTimestampResolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548682\">548682<\/a> Fix NPE in FS$FileStoreAttributeCache.getFsTimestampResolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548648\">548648<\/a> FS: ignore AccessDeniedException when measuring timestamp resolution<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548598\">548598<\/a> Use FileChannel.open to touch file and set mtime to now<\/li>\n<li>FileSnapshot#equals: consider UNKNOWN_SIZE<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Timeout measuring file timestamp resolution after 2 seconds<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix RacyGitTests#testRacyGitDetection<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change RacyGitTests to create a racy git situation in a stable way<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548312\">548312<\/a> Fix non-deterministic hash of archives created by ArchiveCommand<\/li>\n<li>In LockFile#waitForStatChange wait in units of file time resolution<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>update orbit to R20190602212107-2019-06<\/li>\n<li>update dependencies\n<ul><li>com.jcraft.jsch\" version to 0.1.55.v20190404-1902<\/li>\n<li>org.apache.httpcomponents.httpclient to 4.5.6.v20190503-0009<\/li>\n<li>org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\n<li>org.mockito to 2.23.0.v20190527-1420<\/li>\n<li>org.objenesis to 2.6.0.v20180420-1519<\/li>\n<li>net.bytebuddy.byte-buddy 1.9.0.v20181107-1410<\/li>\n<li>net.bytebuddy.byte-buddy-agent 1.9.0.v20181106-1534<\/li>\n<\/ul><\/li>\n<li>update Maven plugins\n<ul><li>ecj to 3.17.0<\/li>\n<li>error_prone_core to 2.3.3<\/li>\n<li>jacoco-maven-plugin to 0.8.4<\/li>\n<li>japicmp-maven-plugin to 0.14.1<\/li>\n<li>maven-compiler-plugin to 3.8.1<\/li>\n<li>maven-deploy-plugin to 3.0.0-M1<\/li>\n<li>maven-enforcer-plugin to 3.0.0-M2<\/li>\n<li>maven-install-plugin to 3.0.0-M1<\/li>\n<li>maven-jar-plugin to 3.1.2<\/li>\n<li>maven-javadoc-plugin to 3.1.0<\/li>\n<li>maven-jxr-plugin to 3.0.0<\/li>\n<li>maven-pmd-plugin to 3.12.0<\/li>\n<li>maven-resources-plugin to 3.1.0<\/li>\n<li>maven-shade-plugin to 3.2.1<\/li>\n<li>maven-source-plugin to 3.1.0<\/li>\n<li>maven-surefire-plugin to 3.0.0-M3<\/li>\n<li>plexus-compiler-eclipse to 2.8.5<\/li>\n<li>plexus-compiler-javac to 2.8.5<\/li>\n<li>plexus-compiler-javac-errorprone to 2.8.5<\/li>\n<li>spotbugs-maven-plugin to 3.1.12<\/li>\n<li>tycho to 1.3.0<\/li>\n<li>tycho-pack200a-plugin to 1.3.0<\/li>\n<li>tycho-pack200b-plugin to 1.3.0<\/li>\n<\/ul><\/li>\n<li>cleanup Maven warnings\n<ul><li>pin version of all used Maven plugins<\/li>\n<li>remove deprecated way to declare minimum Maven version<\/li>\n<\/ul><\/li>\n<li>Bazel\n<ul><li>Bazel: enable logging for tests in org.eclipse.jgit.test<\/li>\n<li>Increase bazel timeout for long running tests<\/li>\n<li>Bazel: Fix lint warning flagged by buildifier<\/li>\n<li>Update bazlets to latest version<\/li>\n<li>Bazel: Add missing dependencies for ArchiveCommandTest<\/li>\n<\/ul><\/li>\n<li>Stop using deprecated Constants.CHARACTER_ENCODING<\/li>\n<li>Reuse FileUtils to recursively delete files created by tests<\/li>\n<li>Add test for racy git detection in FileSnapshot<\/li>\n<li>Fix org.eclipse.jdt.core.prefs of org.eclipse.jgit.junit<\/li>\n<li>Enhance RepeatRule to report number of failures at the end<\/li>\n<li>Fix FileSnapshotTests for filesystem with high timestamp resolution<\/li>\n<li>Retry deleting test files in FileBasedConfigTest<\/li>\n<li>Measure filesystem timestamp resolution already in test setup<\/li>\n<li>Delete unused FileTreeIteratorWithTimeControl<\/li>\n<li>Add missing javadoc in org.eclipse.jgit.junit<\/li>\n<li>Deprecate Constants.CHARACTER_ENCODING in favor of StandardCharsets.UTF_8<\/li>\n<li>Make inner classes static where possible<\/li>\n<li>Ensure root cause of lock creation failures is logged<\/li>\n<li>Implement toString in MockSystemReader and MockConfig<\/li>\n<li>LockFile: log exception if creation of lock file failed<\/li>\n<li>Add debug trace for FileSnapshot<\/li>\n<\/ul>","summary":"","value":"<h2>Features (supporting fixes)<\/h2>\r\n\r\n<ul>\r\n\t<li>Cache FileStoreAttributes per directory, cache size can be configured via FileStoreAttributes#configureAttributesPathCache<\/li>\r\n\t<li>Persist minimal racy threshold and allow manual configuration\r\n\t<ul>\r\n\t\t<li>Config section is &quot;filesystem&quot;<\/li>\r\n\t\t<li>Config subsection is concatenation of\r\n\t\t<ul>\r\n\t\t\t<li>Java vendor (system property &quot;<span style=\"font-family:Courier New,Courier,monospace\">java.vendor<\/span>&quot;)<\/li>\r\n\t\t\t<li>Java version (system property &quot;<span style=\"font-family:Courier New,Courier,monospace\">java.version<\/span>&quot;)<\/li>\r\n\t\t\t<li><span style=\"font-family:Courier New,Courier,monospace\">FileStore<\/span>&#39;s name, on Windows we use the attribute <span style=\"font-family:Courier New,Courier,monospace\">volume:vsn<\/span> instead since &nbsp;the name is not necessarily unique.<\/li>\r\n\t\t\t<li>separated by &#39;|&#39;<\/li>\r\n\t\t\t<li>e.g. &quot;<span style=\"font-family:Courier New,Courier,monospace\">AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1<\/span>&quot;<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>The config key for minmal racy threshold is &quot;<span style=\"font-family:Courier New,Courier,monospace\">minRacyThreshold<\/span>&quot; as a time value, supported time units are those supported by&nbsp;<span style=\"font-family:Courier New,Courier,monospace\">DefaultTypedConfigGetter#getTimeUnit<\/span><\/li>\r\n\t\t<li>If the minimal racy threshold is configured for a given <span style=\"font-family:Courier New,Courier,monospace\">FileStore<\/span> the configured value is used instead of measuring it.<\/li>\r\n\t\t<li>When the minimal racy threshold was measured it is persisted in <span style=\"font-family:Courier New,Courier,monospace\">~\/.gitconfig<\/span>.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Measure minimum racy interval to auto-configure <span style=\"font-family:Courier New,Courier,monospace\">FileSnapshot<\/span><\/li>\r\n\t<li>Measure stored file timestamp resolution instead of time to touch file<\/li>\r\n\t<li>Use Instant for smudge time in <span style=\"font-family:Courier New,Courier,monospace\">DirCache<\/span> and <span style=\"font-family:Courier New,Courier,monospace\">DirCacheEntry<\/span><\/li>\r\n\t<li>Use Instant instead of milliseconds for filesystem timestamp handling This enables higher file timestamp resolution on filesystems like ext4, APFS (1ns) or NTFS (100ns) providing high timestamp resolution on filesystem level.\r\n\t<ul>\r\n\t\t<li>Note: on some OSes Java 8, 9 truncate milliseconds\r\n\t\t<ul>\r\n\t\t\t<li>see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8177809, fixed in Java 10<\/li>\r\n\t\t\t<li><span style=\"font-family:Courier New,Courier,monospace\">UnixFileAttributes<\/span> truncates timestamp resolution to microseconds when converting the internal representation to <span style=\"font-family:Courier New,Courier,monospace\">FileTime<\/span> exposed in the API,&nbsp;see https:\/\/bugs.openjdk.java.net\/browse\/JDK-8181493<\/li>\r\n\t\t\t<li><span style=\"font-family:Courier New,Courier,monospace\">WindowsFileAttributes<\/span> also provides only microsecond resolution<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Add support for nanoseconds and microseconds for <span style=\"font-family:Courier New,Courier,monospace\">Config#getTimeUnit<\/span><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>, <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Persist filesystem timestamp resolution and allow manual configuration. To enable persisting filesystem timestamp resolution per FileStore add a new config section to the user global git configuration:\r\n\t<ul>\r\n\t\t<li>Config section is &quot;<span style=\"font-family:Courier New,Courier,monospace\">filesystem<\/span>&quot;<\/li>\r\n\t\t<li>Config subsection is concatenation of\r\n\t\t<ul>\r\n\t\t\t<li>Java vendor (system property &quot;<span style=\"font-family:Courier New,Courier,monospace\">java.vendor<\/span>&quot;)<\/li>\r\n\t\t\t<li>runtime version (system property &quot;<span style=\"font-family:Courier New,Courier,monospace\">java.version<\/span>&quot;)<\/li>\r\n\t\t\t<li><span style=\"font-family:Courier New,Courier,monospace\">FileStore<\/span>&#39;s name<\/li>\r\n\t\t\t<li>separated by &#39;|&#39;<\/li>\r\n\t\t\t<li>e.g.&nbsp;&quot;<span style=\"font-family:Courier New,Courier,monospace\">AdoptOpenJDK|1.8.0_212-b03|\/dev\/disk1s1<\/span>&quot;<\/li>\r\n\t\t\t<li>config key for timestamp resolution is &quot;<span style=\"font-family:Courier New,Courier,monospace\">timestampResolution<\/span>&quot; as a time value, supported time units are those supported by&nbsp;<span style=\"font-family:Courier New,Courier,monospace\">DefaultTypedConfigGetter#getTimeUnit<\/span><\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>If timestamp resolution is already configured for a given <span style=\"font-family:Courier New,Courier,monospace\">FileStore<\/span> the configured value is used instead of measuring the resolution.<\/li>\r\n\t\t<li>When timestamp resolution was measured it is persisted in <span style=\"font-family:Courier New,Courier,monospace\">~\/.gitconfig<\/span><\/li>\r\n\t\t<li>Caution: do not attempt to manually configure a higher timestamp resolution than supported by the Java version being used at runtime.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Optionally measure filesystem timestamp resolution asynchronously\r\n\t<ul>\r\n\t\t<li>In order to enable measurement in the background call <span style=\"font-family:Courier New,Courier,monospace\">FileStoreAttributeCache.setAsyncfileStoreAttrCache(true)<\/span><br \/>\r\n\t\tbefore the first access to cached <span style=\"font-family:Courier New,Courier,monospace\">FileStore<\/span> attributes.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=319142\">319142<\/a> Avoid sign extension when comparing mtime with <span style=\"font-family:Courier New,Courier,monospace\">Instant#getEpochSecond<\/span><\/li>\r\n\t<li>Fix NPE in <span style=\"font-family:Courier New,Courier,monospace\">RebaseTodoFile#parseComments<\/span><\/li>\r\n\t<li>Fix NPE in <span style=\"font-family:Courier New,Courier,monospace\">ObjectIdOwnerMap#get<\/span><\/li>\r\n\t<li>Fix NPE in <span style=\"font-family:Courier New,Courier,monospace\">CommitOnlyTest#getHead<\/span><\/li>\r\n\t<li>Cache user global and system-wide git configurations in <span style=\"font-family:Courier New,Courier,monospace\">SystemReader<\/span><\/li>\r\n\t<li>Fix javadoc for <span style=\"font-family:Courier New,Courier,monospace\">SystemReader#getInstance<\/span><\/li>\r\n\t<li>Ensure tests use <span style=\"font-family:Courier New,Courier,monospace\">MockSystemReader<\/span><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544164\">544164<\/a> Make <span style=\"font-family:Courier New,Courier,monospace\">supportsAtomicCreateNewFile<\/span> return true as default<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547400\">547400<\/a> Handle <span style=\"font-family:Courier New,Courier,monospace\">InvalidPathException<\/span> in <span style=\"font-family:Courier New,Courier,monospace\">FS_POSIX#createNewFileAtomic<\/span><\/li>\r\n\t<li>Override <span style=\"font-family:Courier New,Courier,monospace\">FileBasedConfig<\/span>&#39;s save method in <span style=\"font-family:Courier New,Courier,monospace\">MockConfig<\/span><\/li>\r\n\t<li>Fix <span style=\"font-family:Courier New,Courier,monospace\">OpenSshConfigTest#config<\/span>: use <span style=\"font-family:Courier New,Courier,monospace\">FS.DETECTED<\/span> instead of <span style=\"font-family:Courier New,Courier,monospace\">db.getFS()<\/span><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548947\">548947<\/a> Android: workaround <span style=\"font-family:Courier New,Courier,monospace\">SecurityException<\/span> in <span style=\"font-family:Courier New,Courier,monospace\">FS#getFsTimestampResolution<\/span><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548682\">548682<\/a> Fix NPE in <span style=\"font-family:Courier New,Courier,monospace\">FS$FileStoreAttributeCache.getFsTimestampResolution<\/span><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548648\">548648<\/a> FS: ignore <span style=\"font-family:Courier New,Courier,monospace\">AccessDeniedException<\/span> when measuring timestamp resolution<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548598\">548598<\/a> Use <span style=\"font-family:Courier New,Courier,monospace\">FileChannel.open <\/span>to touch file and set mtime to now<\/li>\r\n\t<li><span style=\"font-family:Courier New,Courier,monospace\">FileSnapshot#equals<\/span>: consider UNKNOWN_SIZE<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Timeout measuring file timestamp resolution after 2 seconds<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548188\">548188<\/a> Fix <span style=\"font-family:Courier New,Courier,monospace\">RacyGitTests#testRacyGitDetection<\/span><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Change <span style=\"font-family:Courier New,Courier,monospace\">RacyGitTests<\/span> to create a racy git situation in a stable way<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548312\">548312<\/a> Fix non-deterministic hash of archives created by <span style=\"font-family:Courier New,Courier,monospace\">ArchiveCommand<\/span><\/li>\r\n\t<li>In <span style=\"font-family:Courier New,Courier,monospace\">LockFile#waitForStatChange<\/span> wait in units of file time resolution<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>update orbit to R20190602212107-2019-06<\/li>\r\n\t<li>update dependencies\r\n\t<ul>\r\n\t\t<li>com.jcraft.jsch&quot; version to 0.1.55.v20190404-1902<\/li>\r\n\t\t<li>org.apache.httpcomponents.httpclient to 4.5.6.v20190503-0009<\/li>\r\n\t\t<li>org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\r\n\t\t<li>org.mockito to 2.23.0.v20190527-1420<\/li>\r\n\t\t<li>org.objenesis to 2.6.0.v20180420-1519<\/li>\r\n\t\t<li>net.bytebuddy.byte-buddy 1.9.0.v20181107-1410<\/li>\r\n\t\t<li>net.bytebuddy.byte-buddy-agent 1.9.0.v20181106-1534<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>update Maven plugins\r\n\t<ul>\r\n\t\t<li>ecj to 3.17.0<\/li>\r\n\t\t<li>error_prone_core to 2.3.3<\/li>\r\n\t\t<li>jacoco-maven-plugin to 0.8.4<\/li>\r\n\t\t<li>japicmp-maven-plugin to 0.14.1<\/li>\r\n\t\t<li>maven-compiler-plugin to 3.8.1<\/li>\r\n\t\t<li>maven-deploy-plugin to 3.0.0-M1<\/li>\r\n\t\t<li>maven-enforcer-plugin to 3.0.0-M2<\/li>\r\n\t\t<li>maven-install-plugin to 3.0.0-M1<\/li>\r\n\t\t<li>maven-jar-plugin to 3.1.2<\/li>\r\n\t\t<li>maven-javadoc-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-jxr-plugin to 3.0.0<\/li>\r\n\t\t<li>maven-pmd-plugin to 3.12.0<\/li>\r\n\t\t<li>maven-resources-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-shade-plugin to 3.2.1<\/li>\r\n\t\t<li>maven-source-plugin to 3.1.0<\/li>\r\n\t\t<li>maven-surefire-plugin to 3.0.0-M3<\/li>\r\n\t\t<li>plexus-compiler-eclipse to 2.8.5<\/li>\r\n\t\t<li>plexus-compiler-javac to 2.8.5<\/li>\r\n\t\t<li>plexus-compiler-javac-errorprone to 2.8.5<\/li>\r\n\t\t<li>spotbugs-maven-plugin to 3.1.12<\/li>\r\n\t\t<li>tycho to 1.3.0<\/li>\r\n\t\t<li>tycho-pack200a-plugin to 1.3.0<\/li>\r\n\t\t<li>tycho-pack200b-plugin to 1.3.0<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>cleanup Maven warnings\r\n\t<ul>\r\n\t\t<li>pin version of all used Maven plugins<\/li>\r\n\t\t<li>remove deprecated way to declare minimum Maven version<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Bazel\r\n\t<ul>\r\n\t\t<li>Bazel: enable logging for tests in <span style=\"font-family:Courier New,Courier,monospace\">org.eclipse.jgit.test<\/span><\/li>\r\n\t\t<li>Increase bazel timeout for long running tests<\/li>\r\n\t\t<li>Bazel: Fix lint warning flagged by buildifier<\/li>\r\n\t\t<li>Update bazlets to latest version<\/li>\r\n\t\t<li>Bazel: Add missing dependencies for <span style=\"font-family:Courier New,Courier,monospace\">ArchiveCommandTest<\/span><\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Stop using deprecated <span style=\"font-family:Courier New,Courier,monospace\">Constants.CHARACTER_ENCODING<\/span><\/li>\r\n\t<li>Reuse <span style=\"font-family:Courier New,Courier,monospace\">FileUtils<\/span> to recursively delete files created by tests<\/li>\r\n\t<li>Add test for racy git detection in <span style=\"font-family:Courier New,Courier,monospace\">FileSnapshot<\/span><\/li>\r\n\t<li>Fix <span style=\"font-family:Courier New,Courier,monospace\">org.eclipse.jdt.core.prefs<\/span> of <span style=\"font-family:Courier New,Courier,monospace\">org.eclipse.jgit.junit<\/span><\/li>\r\n\t<li>Enhance <span style=\"font-family:Courier New,Courier,monospace\">RepeatRule<\/span> to report number of failures at the end<\/li>\r\n\t<li>Fix <span style=\"font-family:Courier New,Courier,monospace\">FileSnapshotTests<\/span> for filesystem with high timestamp resolution<\/li>\r\n\t<li>Retry deleting test files in <span style=\"font-family:Courier New,Courier,monospace\">FileBasedConfigTest<\/span><\/li>\r\n\t<li>Measure filesystem timestamp resolution already in test setup<\/li>\r\n\t<li>Delete unused <span style=\"font-family:Courier New,Courier,monospace\">FileTreeIteratorWithTimeControl<\/span><\/li>\r\n\t<li>Add missing javadoc in <span style=\"font-family:Courier New,Courier,monospace\">org.eclipse.jgit.junit<\/span><\/li>\r\n\t<li>Deprecate Constants.CHARACTER_ENCODING in favor of StandardCharsets.UTF_8<\/li>\r\n\t<li>Make inner classes static where possible<\/li>\r\n\t<li>Ensure root cause of lock creation failures is logged<\/li>\r\n\t<li>Implement <span style=\"font-family:Courier New,Courier,monospace\">toString<\/span> in <span style=\"font-family:Courier New,Courier,monospace\">MockSystemReader<\/span> and <span style=\"font-family:Courier New,Courier,monospace\">MockConfig<\/span><\/li>\r\n\t<li><span style=\"font-family:Courier New,Courier,monospace\">LockFile<\/span>: log exception if creation of lock file failed<\/li>\r\n\t<li>Add debug trace for <span style=\"font-family:Courier New,Courier,monospace\">FileSnapshot<\/span><\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.9","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.9","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-06-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547332\">547332<\/a> Determine hard-linking and nlink support per FileStore<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=488572\">488572<\/a> Support reading and writing cookies. The git config entries http.cookieFile and http.saveCookies are now supported.<\/li>\n<li>Repository: Add getIdentifier() method<\/li>\n<li>cli: Add the --always option to describe<\/li>\n<li>DescribeCommand: Support the \"always\" option<\/li>\n<li>cli: Add the --tags option to describe<\/li>\n<li>RevWalk: new method createReachabilityChecker()<\/li>\n<li>BitmapCalculator: Get the reachability bitmap of a commit<\/li>\n<li>ReachabilityChecker: Default implementation with a RevWalk<\/li>\n<li>CLI diff: Add \"--staged\" as alias to \"--cached\"<\/li>\n<li>Repository: Add getIdentifier() method to avoid instanceof operator<\/li>\n<li>Extend FileSnapshot for packfiles to also use checksum to detect changes<\/li>\n<li>Optionally wait opening new packfile until it can't be racy anymore. If pack.waitPreventRacyPack = true (default is false) and packfile size &gt; pack.minSizePreventRacyPack (default is 100 MB) wait after a new packfile was written and before it is opened until it cannot be racy anymore.<\/li>\n<li>Include filekey file attribute (inode on *nix filesystems) when comparing FileSnapshots<\/li>\n<li>Measure file timestamp resolution used in FileSnapshot<\/li>\n<li>  <\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li>BitmappedReachabilityChecker: Reachability check using bitmaps<\/li>\n<li>tree:&lt;depth&gt;: do not revisit tree during packing<\/li>\n<li>tree:&lt;depth&gt; should not traverse overly-deep trees<\/li>\n<li>Preliminary support for tree:&lt;depth&gt; filter<\/li>\n<li>Introduce RefDatabase#getTipsWithSha1 to list refs pointing to object<\/li>\n<\/ul><h2>Logging<\/h2>\n<ul><li>Attach deletion failure reason in FileUtils.delete()<\/li>\n<li>Track object inflation time in DfsReaderIoStats<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547724\">547724<\/a> Handle missing \"ours\" stage in WorkingTreeIterator.hasCrLfInIndex()<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529522\">529522<\/a> Retry loading config when locked by another process<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544965\">544965<\/a> Make pull --rebase on an unborn branch do a checkout<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548081\">548081<\/a> Warn if configured cookie file is missing<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545850\">545850<\/a> Handle escaped CR-LF in git config files<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546703\">546703<\/a> DescribeCommand: use glob match instead of path match<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546245\">546245<\/a> Fix off-by-one error in RebaseTodoFile when reading a todo file<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547332\">547332<\/a> Determine hard-linking and nlink support per FileStore<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a> Fix performance degradation introduced with bug fix for <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a><\/li>\n<li>FS_POSIX: Fix reference comparison of Boolean.FALSE<\/li>\n<li>Fix FileSnapshot's consideration of file size<\/li>\n<li>ObjectDirectory: fix closing of obsolete packs<\/li>\n<li>SystemReader: Respect passed-in parent when no system config is present<\/li>\n<li>GPG: check that the key found is a signing key<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545673\">545673<\/a> GPG: use key fingerprint suffix to compare id for signing key<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545673\">545673<\/a> Ignore invalid files in '.gnupg\/private-keys-v1.d'<\/li>\n<li>Process unshallow commits first to fix errors in unshallow git-fetch<\/li>\n<li>DfsRefDatabase: Keep update index when peeling a reference<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547570\">547570<\/a> Update to Orbit R20190602212107<\/li>\n<li>Dependencies\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=541425\">541425<\/a> Upgrade and adapt to Apache MINA sshd client 2.2.0<\/li>\n<li>Upgrade Bouncy Castle to 1.61<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546130\">546130<\/a> Upgrade JSch to 0.1.55<\/li>\n<\/ul><\/li>\n<li>Maven\n<ul><li>Upgrade jacoco-maven-plugin to 0.8.4<\/li>\n<li>Upgrade maven-compiler-plugin to 3.8.1<\/li>\n<li>Upgrade maven-jar-plugin to 3.1.2<\/li>\n<li>Upgrade maven-pmd-plugin to 3.12.0<\/li>\n<li>Upgrade maven-source-plugin to 3.1.0<\/li>\n<li>Upgrade maven surefire plugins version to 2.22.2<\/li>\n<li>Upgrade ecj to 3.17.0<\/li>\n<li>Upgrade spotbugs to 3.1.12<\/li>\n<li>Upgrade Tycho to 1.4.0<\/li>\n<\/ul><\/li>\n<li>Bazel\n<ul><li>Bump minimum Bazel version to 0.26.1<\/li>\n<li>Bazel: Bump skylib library version to 0.8.0<\/li>\n<li>Increase bazel timeout for long running tests<\/li>\n<li>Use bazelisk to switch between used bazel version<\/li>\n<li>Add bazel options to align with those used in Gerrit<\/li>\n<li>Enable error-prone checks by default<\/li>\n<li>Increase severity of most error-prone checks to ERROR<\/li>\n<li>ErrorProne: Increase severity of OperatorPrecedence to ERROR<\/li>\n<li>ErrorProne: Increase severity of FutureReturnValueIgnored to ERROR<\/li>\n<li>Add missing source bundles and add them to a single source feature<\/li>\n<\/ul><\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545906\">545906<\/a> Fix dependencies between features<\/li>\n<li>Introduce a checkNotNull helper<\/li>\n<li>Enhance fsTick() to use filesystem timer resolution<\/li>\n<li>Add debug trace to measure time needed to open pack index<\/li>\n<li>Tune max heap size for tests<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547332\">547332<\/a> Determine hard-linking and nlink support per FileStore<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=488572\">488572<\/a> Support reading and writing cookies.&nbsp;The git config entries <span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\"><span style=\"color:#c0392b\">http.cookieFile<\/span><\/span>&nbsp;and <span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\"><span style=\"color:#c0392b\">http.saveCookies<\/span><\/span>&nbsp;are now supported.<\/li>\r\n\t<li>Repository: Add getIdentifier() method<\/li>\r\n\t<li>cli: Add the --always option to describe<\/li>\r\n\t<li>DescribeCommand: Support the &quot;always&quot; option<\/li>\r\n\t<li>cli: Add the --tags option to describe<\/li>\r\n\t<li>RevWalk: new method createReachabilityChecker()<\/li>\r\n\t<li>BitmapCalculator: Get the reachability bitmap of a commit<\/li>\r\n\t<li>ReachabilityChecker: Default implementation with a RevWalk<\/li>\r\n\t<li>CLI diff: Add &quot;--staged&quot; as alias to &quot;--cached&quot;<\/li>\r\n\t<li>Repository: Add getIdentifier() method to avoid instanceof operator<\/li>\r\n\t<li>Extend FileSnapshot for packfiles to also use checksum to detect changes<\/li>\r\n\t<li>Optionally wait opening new packfile until it can&#39;t be racy anymore. If&nbsp;<span style=\"color:#c0392b\"><span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\">pack.waitPreventRacyPack = true<\/span><\/span> (default is false) and<span style=\"color:#16a085\">&nbsp;<\/span><span style=\"color:#c0392b\"><span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\">packfile size &gt; pack.minSizePreventRacyPack<\/span><\/span> (default is 100 MB) wait after a new packfile was written and before it is opened until it&nbsp;cannot be racy anymore.<\/li>\r\n\t<li>Include filekey file attribute (inode on *nix filesystems) when comparing FileSnapshots<\/li>\r\n\t<li>Measure file timestamp resolution used in FileSnapshot<\/li>\r\n\t<li>&nbsp;&nbsp;<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>BitmappedReachabilityChecker: Reachability check using bitmaps<\/li>\r\n\t<li>tree:&lt;depth&gt;: do not revisit tree during packing<\/li>\r\n\t<li>tree:&lt;depth&gt; should not traverse overly-deep trees<\/li>\r\n\t<li>Preliminary support for tree:&lt;depth&gt; filter<\/li>\r\n\t<li>Introduce RefDatabase#getTipsWithSha1 to list refs pointing to object<\/li>\r\n<\/ul>\r\n\r\n<h2>Logging<\/h2>\r\n\r\n<ul>\r\n\t<li>Attach deletion failure reason in FileUtils.delete()<\/li>\r\n\t<li>Track object inflation time in DfsReaderIoStats<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547724\">547724<\/a>&nbsp;Handle missing &quot;ours&quot; stage in WorkingTreeIterator.hasCrLfInIndex()<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529522\">529522<\/a> Retry loading config when locked by another process<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544965\">544965<\/a> Make pull --rebase on an unborn branch do a checkout<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=548081\">548081<\/a> Warn if configured cookie file is missing<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545850\">545850<\/a> Handle escaped CR-LF in git config files<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546703\">546703<\/a> DescribeCommand: use glob match instead of path match<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546245\">546245<\/a> Fix off-by-one error in RebaseTodoFile when reading a todo file<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547332\">547332<\/a> Determine hard-linking and nlink support per FileStore<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>&nbsp;Fix performance degradation introduced with bug fix for&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a><\/li>\r\n\t<li>FS_POSIX: Fix reference comparison of Boolean.FALSE<\/li>\r\n\t<li>Fix FileSnapshot&#39;s consideration of file size<\/li>\r\n\t<li>ObjectDirectory: fix closing of obsolete packs<\/li>\r\n\t<li>SystemReader: Respect passed-in parent when no system config is present<\/li>\r\n\t<li>GPG: check that the key found is a signing key<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545673\">545673<\/a> GPG: use key fingerprint suffix to compare id for signing key<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545673\">545673<\/a> Ignore invalid files in &#39;.gnupg\/private-keys-v1.d&#39;<\/li>\r\n\t<li>Process unshallow commits first to fix errors in unshallow git-fetch<\/li>\r\n\t<li>DfsRefDatabase: Keep update index when peeling a reference<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=547570\">547570<\/a> Update to Orbit R20190602212107<\/li>\r\n\t<li>Dependencies\r\n\t<ul>\r\n\t\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=541425\">541425<\/a>&nbsp;Upgrade and adapt to Apache MINA sshd client 2.2.0<\/li>\r\n\t\t<li>Upgrade Bouncy Castle to 1.61<\/li>\r\n\t\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546130\">546130<\/a> Upgrade JSch to 0.1.55<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Maven\r\n\t<ul>\r\n\t\t<li>Upgrade jacoco-maven-plugin to 0.8.4<\/li>\r\n\t\t<li>Upgrade maven-compiler-plugin to 3.8.1<\/li>\r\n\t\t<li>Upgrade maven-jar-plugin to 3.1.2<\/li>\r\n\t\t<li>Upgrade maven-pmd-plugin to 3.12.0<\/li>\r\n\t\t<li>Upgrade maven-source-plugin to 3.1.0<\/li>\r\n\t\t<li>Upgrade maven surefire plugins version to 2.22.2<\/li>\r\n\t\t<li>Upgrade ecj to 3.17.0<\/li>\r\n\t\t<li>Upgrade spotbugs to 3.1.12<\/li>\r\n\t\t<li>Upgrade Tycho to 1.4.0<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Bazel\r\n\t<ul>\r\n\t\t<li>Bump minimum Bazel version to 0.26.1<\/li>\r\n\t\t<li>Bazel: Bump skylib library version to 0.8.0<\/li>\r\n\t\t<li>Increase bazel timeout for long running tests<\/li>\r\n\t\t<li>Use bazelisk to switch between used bazel version<\/li>\r\n\t\t<li>Add bazel options to align with those used in Gerrit<\/li>\r\n\t\t<li>Enable error-prone checks by default<\/li>\r\n\t\t<li>Increase severity of most error-prone checks to ERROR<\/li>\r\n\t\t<li>ErrorProne: Increase severity of OperatorPrecedence to ERROR<\/li>\r\n\t\t<li>ErrorProne: Increase severity of FutureReturnValueIgnored to ERROR<\/li>\r\n\t\t<li>Add missing source bundles and add them to a single source feature<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545906\">545906<\/a> Fix dependencies between features<\/li>\r\n\t<li>Introduce a checkNotNull helper<\/li>\r\n\t<li>Enhance fsTick() to use filesystem timer resolution<\/li>\r\n\t<li>Add debug trace to measure time needed to open pack index<\/li>\r\n\t<li>Tune max heap size for tests<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/5.4"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-06-19 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.4.0"}],"state":[{"value":"success"}],"title":"5.4.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.4.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.4.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.4.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-06-05 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<p>The following features were implemented to help fixing <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>:<\/p>\n<ul><li>Extend FileSnapshot for packfiles to also use checksum to detect changes<\/li>\n<li>Optionally wait opening new packfile until it can't be racy anymore. If pack.waitPreventRacyPack = true (default is false) and packfile size &gt; pack.minSizePreventRacyPack (default is 100 MB) wait after a new packfile was written and before it is opened until it cannot be racy anymore.<\/li>\n<li>Include filekey file attribute (inode on *nix filesystems) when comparing FileSnapshots<\/li>\n<li>Measure file timestamp resolution used in FileSnapshot<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a> Fix performance degradation introduced with bug fix for <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a><\/li>\n<li>Fix FileSnapshot's consideration of file size<\/li>\n<li>ObjectDirectory: fix closing of obsolete packs<\/li>\n<li>SystemReader: Respect passed-in parent when no system config is present<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Enhance fsTick() to use filesystem timer resolution<\/li>\n<li>Add debug trace to measure time needed to open pack index<\/li>\n<li>Tune max heap size for tests<\/li>\n<li>Bazel: Increase severity of most error-prone checks to ERROR<\/li>\n<li>Enable error-prone checks by default<\/li>\n<li>Add bazel options to align with those used in Gerrit<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<p>The following features were implemented to help fixing&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>:<\/p>\r\n\r\n<ul>\r\n\t<li>Extend FileSnapshot for packfiles to also use checksum to detect changes<\/li>\r\n\t<li>Optionally wait opening new packfile until it can&#39;t be racy anymore. If&nbsp;<span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\"><span style=\"color:#c0392b\">pack.waitPreventRacyPack = true<\/span><\/span> (default is false) and&nbsp;<span style=\"color:#c0392b\"><span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\">packfile size &gt; pack.minSizePreventRacyPack<\/span><\/span> (default is 100 MB) wait after a new packfile was written and before it is opened until it&nbsp;cannot be racy anymore.<\/li>\r\n\t<li>Include filekey file attribute (inode on *nix filesystems) when comparing FileSnapshots<\/li>\r\n\t<li>Measure file timestamp resolution used in FileSnapshot<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>&nbsp;Fix performance degradation introduced with bug fix for&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a><\/li>\r\n\t<li>Fix FileSnapshot&#39;s consideration of file size<\/li>\r\n\t<li>ObjectDirectory: fix closing of obsolete packs<\/li>\r\n\t<li>SystemReader: Respect passed-in parent when no system config is present<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Enhance fsTick() to use filesystem timer resolution<\/li>\r\n\t<li>Add debug trace to measure time needed to open pack index<\/li>\r\n\t<li>Tune max heap size for tests<\/li>\r\n\t<li>Bazel: Increase severity of most error-prone checks to ERROR<\/li>\r\n\t<li>Enable error-prone checks by default<\/li>\r\n\t<li>Add bazel options to align with those used in Gerrit<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-06-05 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<p>The following features were implemented to help fixing <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>:<\/p>\n<ul><li>Extend FileSnapshot for packfiles to also use checksum to detect changes<\/li>\n<li>Optionally wait opening new packfile until it can't be racy anymore. If pack.waitPreventRacyPack = true (default is false) and packfile size &gt; pack.minSizePreventRacyPack (default is 100 MB) wait after a new packfile was written and before it is opened until it cannot be racy anymore.<\/li>\n<li>Include filekey file attribute (inode on *nix filesystems) when comparing FileSnapshots<\/li>\n<li>Measure file timestamp resolution used in FileSnapshot<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a> Fix performance degradation introduced with bug fix for <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a><\/li>\n<li>Fix FileSnapshot's consideration of file size<\/li>\n<li>ObjectDirectory: fix closing of obsolete packs<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Enhance fsTick() to use filesystem timer resolution<\/li>\n<li>Add debug trace to measure time needed to open pack index<\/li>\n<li>Tune max heap size for tests<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<p>The following features were implemented to help fixing&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>:<\/p>\r\n\r\n<ul>\r\n\t<li>Extend FileSnapshot for packfiles to also use checksum to detect changes<\/li>\r\n\t<li>Optionally wait opening new packfile until it can&#39;t be racy anymore. If&nbsp;<span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\"><span style=\"color:#c0392b\">pack.waitPreventRacyPack = true <\/span><\/span>(default is false) and&nbsp;<span style=\"color:#c0392b\"><span style=\"font-family:Lucida Sans Unicode,Lucida Grande,sans-serif\">packfile size &gt; pack.minSizePreventRacyPack<\/span><\/span> (default is 100 MB) wait after a new packfile was written and before it is opened until it&nbsp;cannot be racy anymore.<\/li>\r\n\t<li>Include filekey file attribute (inode on *nix filesystems) when comparing FileSnapshots<\/li>\r\n\t<li>Measure file timestamp resolution used in FileSnapshot<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546891\">546891<\/a>&nbsp;Fix performance degradation introduced with bug fix for&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a><\/li>\r\n\t<li>Fix FileSnapshot&#39;s consideration of file size<\/li>\r\n\t<li>ObjectDirectory: fix closing of obsolete packs<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Enhance fsTick() to use filesystem timer resolution<\/li>\r\n\t<li>Add debug trace to measure time needed to open pack index<\/li>\r\n\t<li>Tune max heap size for tests<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.8","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.8","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-28 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545162\">545162<\/a> Fix diff when deleted submodule is replaced by normal files<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545920\">545920<\/a> Apache MINA sshd: fix cloning of large repositories<\/li>\n<li>ObjectUploadListener: Add callback interface which is invoked after object upload was completed.<\/li>\n<li>Fix GC to delete empty fanout directories after repacking<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545162\">545162<\/a> Fix diff when deleted submodule is replaced by normal files<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545920\">545920<\/a> Apache MINA sshd: fix cloning of large repositories<\/li>\r\n\t<li>ObjectUploadListener: Add callback interface which is invoked after object upload was completed.<\/li>\r\n\t<li>Fix GC to delete empty fanout directories after repacking<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545162\">545162<\/a> Fix diff when deleted submodule is replaced by normal files<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545920\">545920<\/a> Apache MINA sshd: fix cloning of large repositories<\/li>\n<li>ObjectUploadListener: Add callback interface which is invoked after object upload was completed.<\/li>\n<li>Fix GC to delete empty fanout directories after repacking<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<li>Fix error log message in ObjectDirectory.handlePackError()<\/li>\n<li>Properly format pack checksums in PackFile.idx()<\/li>\n<li>Cancel gc if thread was interrupted<\/li>\n<li>PackFile: report correct message for checksum mismatch<\/li>\n<li>ObjectDirectory: extra logging on packfile exceptions<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Stop using native.git_repository<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545162\">545162<\/a> Fix diff when deleted submodule is replaced by normal files<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=545920\">545920<\/a> Apache MINA sshd: fix cloning of large repositories<\/li>\r\n\t<li>ObjectUploadListener: Add callback interface which is invoked after object upload was completed.<\/li>\r\n\t<li>Fix GC to delete empty fanout directories after repacking<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n\t<li>Fix error log message in ObjectDirectory.handlePackError()<\/li>\r\n\t<li>Properly format pack checksums in PackFile.idx()<\/li>\r\n\t<li>Cancel gc if thread was interrupted<\/li>\r\n\t<li>PackFile: report correct message for checksum mismatch<\/li>\r\n\t<li>ObjectDirectory: extra logging on packfile exceptions<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Stop using native.git_repository<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.2.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.2.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-20 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>ObjectUploadListener: Add callback interface which is invoked after object upload was completed.<\/li>\n<li>Fix GC to delete empty fanout directories after repacking<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>ObjectUploadListener: Add callback interface which is invoked after object upload was completed.<\/li>\r\n\t<li>Fix GC to delete empty fanout directories after repacking<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.7","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>Fix GC to delete empty fanout directories after repacking<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix GC to delete empty fanout directories after repacking<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.8","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.8","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>Fix GC to delete empty fanout directories after repacking<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix GC to delete empty fanout directories after repacking<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.10","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.10","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.9","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.9","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-04-15 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn't modified<\/li>\n<li>Remember the cause for invalidating a packfile<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=546190\">546190<\/a> Fix pack files scan when filesnapshot isn&#39;t modified<\/li>\r\n\t<li>Remember the cause for invalidating a packfile<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.7","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-20 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>Expose the filter blob limit in UploadPack<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=542611\">542611<\/a> Enable cloning only specific tags<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543152\">543152<\/a> SshdSessionFactory: generalize providing default keys<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543579\">543579<\/a> Allow to check for signing key<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=382212\">382212<\/a> Implement signing commits using BouncyCastle<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=382212\">382212<\/a> Add signing options to commit CLI<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=382212\">382212<\/a> Allow CommitCommand to sign commits<\/li>\n<li>RefDatabase\/Ref: Add versioning to reference database<\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a> Reduce contention on PackFile.idx() function.<\/li>\n<li>UploadPack: Read wanted refs in one shot<\/li>\n<li>Lazily open ReadableChannel in BlockBasedFile.getOrLoadBlock<\/li>\n<li>Lock DfsBlockCache while loading object references to avoid concurrent index loading<\/li>\n<li>RefDirectory: Look up several exact refs in one shot<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a> Fix corruption of packfile list due to concurrent access during GC<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a> Reduce contention on accessing packfile index<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544982\">544982<\/a> Avoid NPE in ObjectId.isId()<\/li>\n<li>Fix error log message in ObjectDirectory.handlePackError()<\/li>\n<li>Properly format pack checksums in PackFile.idx()<\/li>\n<li>Cancel gc if thread was interrupted<\/li>\n<li>PackFile: report correct message for checksum mismatch error<\/li>\n<li>ObjectDirectory: Clean up logging<\/li>\n<li>ObjectDirectory: extra logging on packfile exceptions<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544735\">544735<\/a> CLI diff command: add option metaVar for --src-prefix and --dst-prefix<\/li>\n<li>ResolveMerger: Destroy TemporaryBuffer on unchecked exceptions<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544797\">544797<\/a> On Windows use %APPDATA%\\gnupg as GPG directory if it exists<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: tighten check for --preserve-merges on --continue<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: fix ONTO_NAME, and --preserve-merges is interactive<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: use orig-head to abort<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: use orig-head in addition to head<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=470643\">470643<\/a> Fix core.autocrlf for non-normalized index<\/li>\n<li>Strongly reference indices in DfsPackFile<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544513\">544513<\/a> Fix NPE in PlotCommitList<\/li>\n<li>Fix bug in copyPackBypassCache's skip 'PACK' header logic<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543956\">543956<\/a> Atomic file creation: respect that hard-linking may not be allowed<\/li>\n<li>Fix NotDirectoryException in GC.deleteEmptyRefsFolders<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=542446\">542446<\/a> RenameBranchCommand: more consistent handling of short ref names<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543390\">543390<\/a> Handle premature EOF in BundleFetchConnection<\/li>\n<li>pgm: Handle exceptions to avoid unnecessary stack traces in command output<\/li>\n<li>pgm: propagate generic exceptions when throwing Die exception<\/li>\n<li>dfs: Remove synchronization in BlockBasedFile#LazyChannel<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=530771\">530771<\/a> Fix \"jgit checkout -f\" to overwrite dirty worktree files<\/li>\n<li>Repository: Don't swallow IOException but propagate them instead<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=542845\">542845<\/a> Apache MINA sshd client: less aggressive key file name caching<\/li>\n<li>Fix detection of \"initial checkout\" after cloning<\/li>\n<li>RefDirectory: Do not use search path to find additional refs<\/li>\n<li>RefDirectory: Fire RefsChangedEvent on error, too<\/li>\n<li>UploadPack: Prevent setting null protocolV2Hook<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Bazel: Stop using native.git_repository<\/li>\n<li>Update Orbit to R20190226160451<\/li>\n<li>Update README<\/li>\n<li>Upgrade error_prone_core to 2.3.3<\/li>\n<li>Upgrade jacoco-maven-plugin to 0.8.3<\/li>\n<li>Upgrade Jetty to 9.4.14<\/li>\n<li>Upgrade maven-jar-plugin to 3.1.1<\/li>\n<li>Upgrade maven-javadoc-plugin to 3.1.0<\/li>\n<li>Update org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\n<li>Update org.apache.httpcomponents.httpclient.source to 4.5.6.v20190123-2215<\/li>\n<li>Update org.bouncycastle.bcpg to 1.60.0.v20181210-2057<\/li>\n<li>Update org.bouncycastle.pkix to 1.60.0.v20181210-2057<\/li>\n<li>Update org.bouncycastle.prov to 1.60.0.v20181210-2057<\/li>\n<li>Upgrade orb.eclipse.jdt:ecj to 3.16.0<\/li>\n<li>Update org.tukaani.xz to 1.8.0.v20180207-1613<\/li>\n<li>Upgrade plexus-compiler-eclipse to 2.8.5<\/li>\n<li>Upgrade plexus-compiler-javac-errorprone to 2.8.5<\/li>\n<li>Upgrade spotbugs to 3.1.11<\/li>\n<li>Upgrade Tycho to 1.3<\/li>\n<li>Upgrade wagon-ssh to 3.3.2<\/li>\n<li>Delete jgit-4.5 target platform<\/li>\n<li>Add 4.11-staging target platform<\/li>\n<li>Fix tools\/version.sh<\/li>\n<li>Make TestRepository AutoCloseable<\/li>\n<li>Change RacyGitTests to create a racy git situation in a stable way<\/li>\n<li>Capture test coverage and add an aggregate test coverage report<\/li>\n<li>Enable japicmp for new SSH bundle; update its baseline<\/li>\n<\/ul><h2>Deprecations and Refactorings<\/h2>\n<ul><li>CommitBuilder: Deprecate setEncoding(String)<\/li>\n<li>Deprecate Repository#hasObject<\/li>\n<li>Deprecate RawParseUtils.UTF8-CHARSET<\/li>\n<li>Move BaseReceivePack#advertisedRefs getter and setter to ReceivePack<\/li>\n<li>Move BaseReceivePack#walk getter to ReceivePack<\/li>\n<li>Move BaseReceivePack#db getter to ReceivePack<\/li>\n<li>Move BaseReceivePack#pushCert getter and setter to ReceivePack<\/li>\n<li>RefDatabase: Introduce findRef synonym for getRef<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>Expose the filter blob limit in UploadPack<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=542611\">542611<\/a> Enable cloning only specific tags<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543152\">543152<\/a> SshdSessionFactory: generalize providing default keys<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543579\">543579<\/a> Allow to check for signing key<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=382212\">382212<\/a> Implement signing commits using BouncyCastle<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=382212\">382212<\/a> Add signing options to commit CLI<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=382212\">382212<\/a> Allow CommitCommand to sign commits<\/li>\r\n\t<li>RefDatabase\/Ref: Add versioning to reference database<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a> Reduce contention on PackFile.idx() function.<\/li>\r\n\t<li>UploadPack: Read wanted refs in one shot<\/li>\r\n\t<li>Lazily open ReadableChannel in BlockBasedFile.getOrLoadBlock<\/li>\r\n\t<li>Lock DfsBlockCache while loading object references to avoid concurrent index loading<\/li>\r\n\t<li>RefDirectory: Look up several exact refs in one shot<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a>&nbsp;Fix corruption of packfile list due to concurrent access during GC<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a>&nbsp;Reduce contention on accessing packfile index<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544982\">544982<\/a> Avoid NPE in ObjectId.isId()<\/li>\r\n\t<li>Fix error log message in ObjectDirectory.handlePackError()<\/li>\r\n\t<li>Properly format pack checksums in PackFile.idx()<\/li>\r\n\t<li>Cancel gc if thread was interrupted<\/li>\r\n\t<li>PackFile: report correct message for checksum mismatch error<\/li>\r\n\t<li>ObjectDirectory: Clean up logging<\/li>\r\n\t<li>ObjectDirectory: extra logging on packfile exceptions<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544735\">544735<\/a> CLI diff command: add option metaVar for --src-prefix and --dst-prefix<\/li>\r\n\t<li>ResolveMerger: Destroy TemporaryBuffer on unchecked exceptions<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544797\">544797<\/a> On Windows use %APPDATA%\\gnupg as GPG directory if it exists<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: tighten check for --preserve-merges on --continue<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: fix ONTO_NAME, and --preserve-merges is interactive<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: use orig-head to abort<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=511487\">511487<\/a> RebaseCommand: use orig-head in addition to head<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=470643\">470643<\/a> Fix core.autocrlf for non-normalized index<\/li>\r\n\t<li>Strongly reference indices in DfsPackFile<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544513\">544513<\/a> Fix NPE in PlotCommitList<\/li>\r\n\t<li>Fix bug in copyPackBypassCache&#39;s skip &#39;PACK&#39; header logic<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543956\">543956<\/a> Atomic file creation: respect that hard-linking may not be allowed<\/li>\r\n\t<li>Fix NotDirectoryException in GC.deleteEmptyRefsFolders<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=542446\">542446<\/a> RenameBranchCommand: more consistent handling of short ref names<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543390\">543390<\/a> Handle premature EOF in BundleFetchConnection<\/li>\r\n\t<li>pgm: Handle exceptions to avoid unnecessary stack traces in command output<\/li>\r\n\t<li>pgm: propagate generic exceptions when throwing Die exception<\/li>\r\n\t<li>dfs: Remove synchronization in BlockBasedFile#LazyChannel<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=530771\">530771<\/a> Fix &quot;jgit checkout -f&quot; to overwrite dirty worktree files<\/li>\r\n\t<li>Repository: Don&#39;t swallow IOException but propagate them instead<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=542845\">542845<\/a> Apache MINA sshd client: less aggressive key file name caching<\/li>\r\n\t<li>Fix detection of &quot;initial checkout&quot; after cloning<\/li>\r\n\t<li>RefDirectory: Do not use search path to find additional refs<\/li>\r\n\t<li>RefDirectory: Fire RefsChangedEvent on error, too<\/li>\r\n\t<li>UploadPack: Prevent setting null protocolV2Hook<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Bazel: Stop using native.git_repository<\/li>\r\n\t<li>Update Orbit to R20190226160451<\/li>\r\n\t<li>Update README<\/li>\r\n\t<li>Upgrade error_prone_core to 2.3.3<\/li>\r\n\t<li>Upgrade jacoco-maven-plugin to 0.8.3<\/li>\r\n\t<li>Upgrade Jetty to 9.4.14<\/li>\r\n\t<li>Upgrade maven-jar-plugin to 3.1.1<\/li>\r\n\t<li>Upgrade maven-javadoc-plugin to 3.1.0<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpcore to 4.4.10.v20190123-2214<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpclient.source to 4.5.6.v20190123-2215<\/li>\r\n\t<li>Update org.bouncycastle.bcpg to 1.60.0.v20181210-2057<\/li>\r\n\t<li>Update org.bouncycastle.pkix to 1.60.0.v20181210-2057<\/li>\r\n\t<li>Update org.bouncycastle.prov to 1.60.0.v20181210-2057<\/li>\r\n\t<li>Upgrade orb.eclipse.jdt:ecj to 3.16.0<\/li>\r\n\t<li>Update org.tukaani.xz to 1.8.0.v20180207-1613<\/li>\r\n\t<li>Upgrade plexus-compiler-eclipse to 2.8.5<\/li>\r\n\t<li>Upgrade plexus-compiler-javac-errorprone to 2.8.5<\/li>\r\n\t<li>Upgrade spotbugs to 3.1.11<\/li>\r\n\t<li>Upgrade Tycho to 1.3<\/li>\r\n\t<li>Upgrade wagon-ssh to 3.3.2<\/li>\r\n\t<li>Delete jgit-4.5 target platform<\/li>\r\n\t<li>Add 4.11-staging target platform<\/li>\r\n\t<li>Fix tools\/version.sh<\/li>\r\n\t<li>Make TestRepository AutoCloseable<\/li>\r\n\t<li>Change RacyGitTests to create a racy git situation in a stable way<\/li>\r\n\t<li>Capture test coverage and add an aggregate test coverage report<\/li>\r\n\t<li>Enable japicmp for new SSH bundle; update its baseline<\/li>\r\n<\/ul>\r\n\r\n<h2>Deprecations and Refactorings<\/h2>\r\n\r\n<ul>\r\n\t<li>CommitBuilder: Deprecate setEncoding(String)<\/li>\r\n\t<li>Deprecate Repository#hasObject<\/li>\r\n\t<li>Deprecate RawParseUtils.UTF8-CHARSET<\/li>\r\n\t<li>Move BaseReceivePack#advertisedRefs getter and setter to ReceivePack<\/li>\r\n\t<li>Move BaseReceivePack#walk getter to ReceivePack<\/li>\r\n\t<li>Move BaseReceivePack#db getter to ReceivePack<\/li>\r\n\t<li>Move BaseReceivePack#pushCert getter and setter to ReceivePack<\/li>\r\n\t<li>RefDatabase: Introduce findRef synonym for getRef<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-20 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.3.0"}],"state":[{"value":"success"}],"title":"5.3.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.3.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.3.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-13 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Bug Fixes<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a> Fix corruption of packfile list due to concurrent access during GC<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a> Reduce contention on accessing packfile index<\/li>\n<\/ul>","summary":"","value":"<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a>&nbsp;Fix corruption of packfile list due to concurrent access during GC<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a>&nbsp;Reduce contention on accessing packfile index<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.6","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-12 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Bug Fixes<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a> Fix corruption of packfile list due to concurrent access during GC<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a> Reduce contention on accessing packfile index<\/li>\n<\/ul>","summary":"","value":"<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a>&nbsp;Fix corruption of packfile list due to concurrent access during GC<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a>&nbsp;Reduce contention on accessing packfile index<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.7","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-12 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Bug Fixes<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a> Fix corruption of packfile list due to concurrent access during GC<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a> Reduce contention on accessing packfile index<\/li>\n<\/ul>","summary":"","value":"<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a>&nbsp;Fix corruption of packfile list due to concurrent access during GC<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=543739\">543739<\/a>&nbsp;Reduce contention on accessing packfile index<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.9","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.9","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-12 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Bug Fixes<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a> Fix corruption of packfile list due to concurrent access during GC<\/li>\n<\/ul>","summary":"","value":"<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a>&nbsp;Fix corruption of packfile list due to concurrent access during GC<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.8","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.8","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-12 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Bug Fixes<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a> Fix corruption of packfile list due to concurrent access during GC<\/li>\n<\/ul>","summary":"","value":"<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=544199\" target=\"_blank\">544199<\/a>&nbsp;Fix corruption of packfile list due to concurrent access during GC<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.6","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-26 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Fixes<\/h2>\n<ul><li>\n<p>UploadPack: Filter refs used for deepen-not resolution<\/p>\n<\/li>\n<li>\n<p>UploadPack: Avoid calling AdvertiseRefsHook twice<\/p>\n<\/li>\n<li>\n<p>UploadPack: Filter refs used for want-ref resolution to ensure any refs the client requests are visible to the client.<\/p>\n<\/li>\n<li>\n<p>UploadPack: Defer want-ref resolution to after parsing<\/p>\n<\/li>\n<li>\n<p>[Security Fix] Call AdvertiseRefsHook to fix the following vulnerability. AdvertiseRefsHook is used to limit the visibility of refs in Gerrit. If this hook is not called, then all refs are treated as visible. In protocol v2, the hook was not called, causing the server to advertise all refs. Even before then, the hook was not called in requests after the capability advertisement, so in transports like HTTP that do not retain state between round-trips, the server would advertise all refs in response to an ls-refs (ls-remote) request. Fix both cases<\/p>\n<\/li>\n<li>\n<p>BasePackConnection: Check for expected length of ref advertisement when using protocol v2<\/p>\n<\/li>\n<li>\n<p>Update last JGit version used to generate API diff to last release<\/p>\n<\/li>\n<li>\n<p>Update list of committers<\/p>\n<\/li>\n<li>\n<p>Add new ssh bundles to scripts used to upload builds to Maven central<\/p>\n<\/li>\n<li>\n<p>Update maven site reports<\/p>\n<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>UploadPack: Filter refs used for deepen-not resolution<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>UploadPack: Avoid calling AdvertiseRefsHook twice<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>UploadPack: Filter refs used for want-ref resolution&nbsp;to ensure any refs the client requests are visible to the client.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>UploadPack: Defer want-ref resolution to after parsing<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>[Security Fix] Call AdvertiseRefsHook to fix the following vulnerability. AdvertiseRefsHook is used to limit the visibility of refs&nbsp;in Gerrit. If this hook is not called, then all refs are treated as visible. In protocol v2, the hook was not called, causing the server to advertise&nbsp;all refs. Even before then, the hook was not called in requests after the&nbsp;capability advertisement, so in transports like HTTP that do not retain state between round-trips, the server would advertise all refs in&nbsp;response to an ls-refs (ls-remote) request. Fix both cases<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>BasePackConnection: Check for expected length of ref advertisement when using protocol v2<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Update last JGit version used to generate API diff to last release<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Update list of committers<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Add new ssh bundles to&nbsp;scripts used to upload builds&nbsp;to Maven central<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Update maven site reports<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.2.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.2.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-26 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Fixes<\/h2>\n<ul><li>\n<p>UploadPack: Avoid calling AdvertiseRefsHook twice. The AdvertiseRefsHook could be called twice when the AdvertiseRefsHook doesn't set this.refs and getAdvertisedOrDefaultRefs is called after getFilteredRefs.<\/p>\n<\/li>\n<li>\n<p>UploadPack: Filter refs used for want-ref resolution to ensure any refs the client requests are visible to the client.<\/p>\n<\/li>\n<li>\n<p>UploadPack: Defer want-ref resolution to after parsing<\/p>\n<\/li>\n<li>\n<p>[Security] Call AdvertiseRefsHook to fix the following vulnerability. AdvertiseRefsHook is used to limit the visibility of refs in Gerrit. If this hook is not called, then all refs are treated as visible. In protocol v2, the hook was not called, causing the server to advertise all refs. Even before then, the hook was not called in requests after the capability advertisement, so in transports like HTTP that do not retain state between round-trips, the server would advertise all refs in response to an ls-refs (ls-remote) request. Fix both cases.<\/p>\n<\/li>\n<li>\n<p>BasePackConnection: Check for expected length of ref advertisement when using protocol v2<\/p>\n<\/li>\n<li>\n<p>Fix DescribeCommand with multiple match options when multiple match options are given in git describe the result must not depend on the order of the match options. JGit wrongly picked the first match using the match options in the order they were defined.<\/p>\n<\/li>\n<li>\n<p>Fix git-describe tie-breakers. Correct behaviour as git 1.7.1.1 is to resolve tie-breakers to choose the most recent tag.<br \/>\n\t <\/p>\n<\/li>\n<\/ul>","summary":"","value":"<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>UploadPack: Avoid calling AdvertiseRefsHook twice. The AdvertiseRefsHook could be called twice when the AdvertiseRefsHook doesn&#39;t set this.refs and getAdvertisedOrDefaultRefs is called after getFilteredRefs.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>UploadPack: Filter refs used for want-ref resolution&nbsp;to ensure any refs the client requests are visible to the client.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>UploadPack: Defer want-ref resolution to after parsing<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>[Security] Call AdvertiseRefsHook to fix the following vulnerability. AdvertiseRefsHook is used to limit the visibility of refs&nbsp;in Gerrit. If this hook is not called, then all refs are treated as visible. In protocol v2, the hook was not called, causing the server to advertise&nbsp;all refs. Even before then, the hook was not called in requests after the&nbsp;capability advertisement, so in transports like HTTP that do not retain state between round-trips, the server would advertise all refs in&nbsp;response to an ls-refs (ls-remote) request. Fix both cases.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>BasePackConnection: Check for expected length of ref advertisement when using protocol v2<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Fix DescribeCommand with multiple match options when multiple match options are given in git describe the result must&nbsp;not depend on the order of the match options. JGit wrongly picked the&nbsp;first match using the match options in the order they were defined.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Fix git-describe tie-breakers.&nbsp;Correct behaviour as git 1.7.1.1 is to resolve tie-breakers to choose the most recent tag.<br \/>\r\n\t&nbsp;<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.5","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-24 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Fixes<\/h2>\n<ul><li>\n<p>Fix DescribeCommand with multiple match options when multiple match options are given in git describe the result must not depend on the order of the match options. JGit wrongly picked the first match using the match options in the order they were defined.<\/p>\n<\/li>\n<li>\n<p>Fix git-describe tie-breakers. Correct behaviour as git 1.7.1.1 is to resolve tie-breakers to choose the most recent tag.<\/p>\n<\/li>\n<li>[Security fix] Fix that AdvertiseRefsHook was not called for git-upload-pack in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\n<\/ul>","summary":"","value":"<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p>Fix DescribeCommand with multiple match options when multiple match options are given in git describe the result must&nbsp;not depend on the order of the match options. JGit wrongly picked the&nbsp;first match using the match options in the order they were defined.<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>Fix git-describe tie-breakers.&nbsp;Correct behaviour as git 1.7.1.1 is to resolve tie-breakers to choose the most recent tag.<\/p>\r\n\t<\/li>\r\n\t<li>[Security fix] Fix that&nbsp;AdvertiseRefsHook was not called for&nbsp;git-upload-pack&nbsp;in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants&nbsp;were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.6","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-24 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Fixes<\/h2>\n<ul><li>[Security fix] Fix that AdvertiseRefsHook was not called for git-upload-pack in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>[Security fix] Fix that&nbsp;AdvertiseRefsHook was not called for&nbsp;git-upload-pack&nbsp;in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants&nbsp;were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.8","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.8","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-24 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Fixes<\/h2>\n<ul><li>[Security fix] Fix that AdvertiseRefsHook was not called for git-upload-pack in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\n<\/ul>","summary":"","value":"<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>[Security fix] Fix that&nbsp;AdvertiseRefsHook was not called for&nbsp;git-upload-pack&nbsp;in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants&nbsp;were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.7","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-24 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Fixes<\/h2>\n<ul><li>[Security fix] Fix that AdvertiseRefsHook was not called for git-upload-pack in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\n<li>Retry stale file handles on .git\/config file to prevent stale file handle exceptions on NFS<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Replace Findbugs with Spotbugs<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>[Security fix] Fix that&nbsp;AdvertiseRefsHook was not called for&nbsp;git-upload-pack&nbsp;in protocol v0 stateless transports, meaning that in Gerrit using AdvertiseRefsHook for validation wants&nbsp;were not validated and a user could fetch anything that is pointed to by any ref (using fetch-by-sha1), as long as they could guess the object name.<\/li>\r\n\t<li>Retry stale file handles on .git\/config file to prevent stale file handle exceptions on NFS<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace Findbugs with Spotbugs<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.5","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520927\">520927<\/a> Apache MINA sshd client: \n<ul><li>Include id_ed25519 in the known default identity files<\/li>\n<li>Enable support for ed25519 keys<\/li>\n<li>Proxy support<\/li>\n<li>Add --ssh option to command-line commands<\/li>\n<li>Use NumberOfPasswordPrompts for encrypted keys<\/li>\n<li>Properly handle HostKeyAlgorithms config<\/li>\n<li>Respect NumberOfPasswordPrompts<\/li>\n<li>Add gssapi-with-mic authentication<\/li>\n<li>Add ssh tests for PreferredAuthentications<\/li>\n<li>Add features for the Apache MINA sshd implementation<\/li>\n<li>Add a new ssh client implementation based on Apach MINA sshd 2.0.0.<\/li>\n<li>Add more ssh tests: pushing, known_host file handling, etc.<\/li>\n<li>TransportSftp: eliminate dependency on Jsch<\/li>\n<li>Factor out a JSch-independent ssh config parser<\/li>\n<li>Ssh tests with an Apache MINA sshd test git server<\/li>\n<\/ul><\/li>\n<li>UploadPack v2 protocol support\n<ul><li>UploadPack: Implement deepen-not for protocol v2 to allow clients to use the --shallow-exclude parameter<\/li>\n<li>Accept protocol v2 server options on fetch and ls-refs requests<\/li>\n<li>UploadPack: Use request instead of field for filterBlobLimt<\/li>\n<li>UploadPack: support deepen-since in protocol v2<\/li>\n<\/ul><\/li>\n<li>Add a method to HttpConnection to get all values of HTTP header defined as list<\/li>\n<li>New GpgConfig for typed access to GPG settings<\/li>\n<li>RepoCommand.RemoteReader: Add method to read contents and mode of file<\/li>\n<li>DfsFsck: Check that .gitmodules in the repository have valid contents<\/li>\n<li>RefDatabase: Support multiple prefixes when querying refs<\/li>\n<\/ul><h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=541622\">541622<\/a> Set git environment variables GIT_DIR and GIT_WORK_TREE when calling hooks<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=467631\">467631<\/a> Fix IndexDiffs for git links<\/li>\n<li>Fix DescribeCommand with multiple match options<\/li>\n<li>Revert C Git 1.7.5 bug workaround which is a patch for dealing with a buggy C Git client v1.7.5 in 2012.<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520927\">520927<\/a> Apache MINA sshd client: don't leak HostConfigEntry<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520927\">520927<\/a> Apache MINA sshd client: test &amp; fix password authentication<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538610\">538610<\/a> Fix git-describe tie-breakers<\/li>\n<li>DepthGenerator: fix multi-child boundary handling causing invalid repository on shallow clone<\/li>\n<li>Fix package exports in org.eclipse.jgit MANIFEST.MF<\/li>\n<li>RepoCommand: Preserve executable bit in &lt;copyfile&gt;<\/li>\n<li>gitignore\/gitattributes: fix matching of \\r<\/li>\n<li>Throw error when deepen-since excludes all commits in \"git fetch --shallow-since=&lt;date&gt; origin &lt;ref&gt;\"<\/li>\n<li>UploadPack v0: Extract \"agent\" client capability at parse time. This makes the treatment of \"agent\" consistent in v0\/v1 and v2.<\/li>\n<li>Ensure pre-push hook properly terminates ref lines by \\n<\/li>\n<li>CheckoutCommand: force flag now allows overwrite ensuring a force checkout will overwrite conflicting files<\/li>\n<li>UploadPack: Return correct peer user agent on v2 requests<\/li>\n<li>InternalPushConnection: don't swallow RuntimeException<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=497290\">497290<\/a> Fix handling of core.eol=native and of crlf attribute on Windows<\/li>\n<li>TextBuiltin: Default to UTF-8 when i18n.logOutputEncoding is not set<\/li>\n<li>SidebandInputStream: Specify charset when calling String.getBytes()<\/li>\n<li>Fix Mylyn commit message template<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538270\">538270<\/a> Config.set-methods should not touch lines from included files<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529825\">529825<\/a> Don't inline included configs on FileBasedConfig.save()<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538768\">538768<\/a> Set TagOpt.AUTO_FOLLOW when not cloning all branches<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=466858\">466858<\/a> Fix fetch refspecs when not cloning all branches<\/li>\n<li>Fix potential NPE in SmudgeFilter#downloadLfsResource<\/li>\n<li>SpotBugs: don't rely on default encoding<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Update Apache commons compress to 1.18.0, fixes <a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-1324\">CVE-2018-1324<\/a> and <a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-11771\">CVE-2018-11771<\/a><\/li>\n<li>Update bcprov-jdk15on used in tests to 1.59<\/li>\n<li>Update Ant to 1.10.5<\/li>\n<li>Update mockito to 2.13.0<\/li>\n<li>Upgrade maven-shade-plugin to 3.2.1<\/li>\n<li>Upgrade Spotbugs to 3.1.8<\/li>\n<li>Update eclipse compiler org.eclipse.jdt:ecj to 3.15.0<\/li>\n<li>Upgrade maven-pmd-plugin to 3.11.0<\/li>\n<li>Upgrade maven-surefire plugins to 2.22.1<\/li>\n<li>Upgrade error_prone_core to 2.3.2<\/li>\n<li>Upgrade wagon-ssh to 3.2.0<\/li>\n<li>Upgrade maven-jxr-plugin to 3.0.0<\/li>\n<li>Upgrade maven-shade-plugin to 3.2.0<\/li>\n<li>Upgrade jacoco-maven-plugin to 0.8.2<\/li>\n<li>Upgrade maven-project-info-reports-plugin to 3.0.0<\/li>\n<li>Upgrade maven-enforcer-plugin to 3.0.0-M2<\/li>\n<li>Ensure same version of maven-surefire-plugin and maven-surefire-report-plugin<\/li>\n<li>Update staging target platform for eclipse platform 4.10<\/li>\n<li>New target platform for 4.9<\/li>\n<li>Bazel: Consume versions directly from lib:versions.bzl in skylib<\/li>\n<li>Bazel: Add missing test dependency on ObjectIdMatcher<\/li>\n<li>Upgrade to Bazel 0.19.0<\/li>\n<li>Bazel: Increase severity of DefaultCharset to ERROR<\/li>\n<li>Bazel: Increase severity of MissingFail to ERROR<\/li>\n<li>Bazel: Increase severity of ExpectedExceptionChecker to ERROR<\/li>\n<li>Bazel: Provide toolchain with activated error prone warnings<\/li>\n<li>Update .mailmap<\/li>\n<\/ul>","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520927\">520927<\/a> Apache MINA sshd client:&nbsp;\r\n\r\n\t<ul>\r\n\t\t<li>Include id_ed25519 in the known default identity files<\/li>\r\n\t\t<li>Enable support for ed25519 keys<\/li>\r\n\t\t<li>Proxy support<\/li>\r\n\t\t<li>Add --ssh option to command-line commands<\/li>\r\n\t\t<li>Use NumberOfPasswordPrompts for encrypted keys<\/li>\r\n\t\t<li>Properly handle HostKeyAlgorithms config<\/li>\r\n\t\t<li>Respect NumberOfPasswordPrompts<\/li>\r\n\t\t<li>Add gssapi-with-mic authentication<\/li>\r\n\t\t<li>Add ssh tests for PreferredAuthentications<\/li>\r\n\t\t<li>Add features for the Apache MINA sshd implementation<\/li>\r\n\t\t<li>Add a new ssh client implementation based on Apach MINA sshd 2.0.0.<\/li>\r\n\t\t<li>Add more ssh tests: pushing, known_host file handling, etc.<\/li>\r\n\t\t<li>TransportSftp: eliminate dependency on Jsch<\/li>\r\n\t\t<li>Factor out a JSch-independent ssh config parser<\/li>\r\n\t\t<li>Ssh tests with an Apache MINA sshd test git server<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>UploadPack v2 protocol support\r\n\t<ul>\r\n\t\t<li>UploadPack: Implement deepen-not for protocol v2 to allow&nbsp;clients to use the --shallow-exclude parameter<\/li>\r\n\t\t<li>Accept protocol v2 server options on fetch and ls-refs requests<\/li>\r\n\t\t<li>UploadPack: Use request instead of field for filterBlobLimt<\/li>\r\n\t\t<li>UploadPack: support deepen-since in protocol v2<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Add a method to HttpConnection to get all values of HTTP header defined as list<\/li>\r\n\t<li>New GpgConfig for typed access to GPG settings<\/li>\r\n\t<li>RepoCommand.RemoteReader: Add method to read contents and mode of file<\/li>\r\n\t<li>DfsFsck: Check that .gitmodules in the repository have valid contents<\/li>\r\n\t<li>RefDatabase: Support multiple prefixes when querying refs<\/li>\r\n<\/ul>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=541622\">541622<\/a> Set git environment variables GIT_DIR and GIT_WORK_TREE when calling hooks<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=467631\">467631<\/a> Fix IndexDiffs for git links<\/li>\r\n\t<li>Fix DescribeCommand with multiple match options<\/li>\r\n\t<li>Revert C Git 1.7.5 bug workaround which is a patch for dealing with a buggy C Git client v1.7.5 in 2012.<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520927\">520927<\/a> Apache MINA sshd client: don&#39;t leak HostConfigEntry<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520927\">520927<\/a> Apache MINA sshd client: test &amp; fix password authentication<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538610\">538610<\/a> Fix git-describe tie-breakers<\/li>\r\n\t<li>DepthGenerator: fix multi-child boundary handling causing invalid repository on shallow clone<\/li>\r\n\t<li>Fix package exports in org.eclipse.jgit MANIFEST.MF<\/li>\r\n\t<li>RepoCommand: Preserve executable bit in &lt;copyfile&gt;<\/li>\r\n\t<li>gitignore\/gitattributes: fix matching of \\r<\/li>\r\n\t<li>Throw error when deepen-since excludes all commits in &quot;git fetch --shallow-since=&lt;date&gt; origin &lt;ref&gt;&quot;<\/li>\r\n\t<li>UploadPack v0: Extract &quot;agent&quot; client capability at parse time. This makes the treatment of &quot;agent&quot; consistent in v0\/v1 and v2.<\/li>\r\n\t<li>Ensure pre-push hook properly terminates ref lines by \\n<\/li>\r\n\t<li>CheckoutCommand: force flag now allows overwrite ensuring a force checkout will overwrite conflicting files<\/li>\r\n\t<li>UploadPack: Return correct peer user agent on v2 requests<\/li>\r\n\t<li>InternalPushConnection: don&#39;t swallow RuntimeException<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=497290\">497290<\/a> Fix handling of core.eol=native and of crlf attribute on Windows<\/li>\r\n\t<li>TextBuiltin: Default to UTF-8 when i18n.logOutputEncoding is not set<\/li>\r\n\t<li>SidebandInputStream: Specify charset when calling String.getBytes()<\/li>\r\n\t<li>Fix Mylyn commit message template<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538270\">538270<\/a> Config.set-methods should not touch lines from included files<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529825\">529825<\/a> Don&#39;t inline included configs on FileBasedConfig.save()<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538768\">538768<\/a> Set TagOpt.AUTO_FOLLOW when not cloning all branches<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=466858\">466858<\/a> Fix fetch refspecs when not cloning all branches<\/li>\r\n\t<li>Fix potential NPE in SmudgeFilter#downloadLfsResource<\/li>\r\n\t<li>SpotBugs: don&#39;t rely on default encoding<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Update Apache commons compress to 1.18.0, fixes <a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-1324\">CVE-2018-1324<\/a>&nbsp;and <a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-11771\">CVE-2018-11771<\/a><\/li>\r\n\t<li>Update bcprov-jdk15on used in tests to 1.59<\/li>\r\n\t<li>Update Ant to 1.10.5<\/li>\r\n\t<li>Update mockito to 2.13.0<\/li>\r\n\t<li>Upgrade maven-shade-plugin to 3.2.1<\/li>\r\n\t<li>Upgrade Spotbugs to 3.1.8<\/li>\r\n\t<li>Update eclipse compiler org.eclipse.jdt:ecj to 3.15.0<\/li>\r\n\t<li>Upgrade maven-pmd-plugin to 3.11.0<\/li>\r\n\t<li>Upgrade maven-surefire plugins to 2.22.1<\/li>\r\n\t<li>Upgrade error_prone_core to 2.3.2<\/li>\r\n\t<li>Upgrade wagon-ssh to 3.2.0<\/li>\r\n\t<li>Upgrade maven-jxr-plugin to 3.0.0<\/li>\r\n\t<li>Upgrade maven-shade-plugin to 3.2.0<\/li>\r\n\t<li>Upgrade jacoco-maven-plugin to 0.8.2<\/li>\r\n\t<li>Upgrade maven-project-info-reports-plugin to 3.0.0<\/li>\r\n\t<li>Upgrade maven-enforcer-plugin to 3.0.0-M2<\/li>\r\n\t<li>Ensure same version of maven-surefire-plugin and maven-surefire-report-plugin<\/li>\r\n\t<li>Update staging target platform for eclipse platform 4.10<\/li>\r\n\t<li>New target platform for 4.9<\/li>\r\n\t<li>Bazel: Consume versions directly from lib:versions.bzl in skylib<\/li>\r\n\t<li>Bazel: Add missing test dependency on ObjectIdMatcher<\/li>\r\n\t<li>Upgrade to Bazel 0.19.0<\/li>\r\n\t<li>Bazel: Increase severity of DefaultCharset to ERROR<\/li>\r\n\t<li>Bazel: Increase severity of MissingFail to ERROR<\/li>\r\n\t<li>Bazel: Increase severity of ExpectedExceptionChecker to ERROR<\/li>\r\n\t<li>Bazel: Provide toolchain with activated error prone warnings<\/li>\r\n\t<li>Update .mailmap<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-19 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.2.0"}],"state":[{"value":"success"}],"title":"5.2.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.2.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.2.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-20 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\n<\/li>\n<li>\n<p>SubmoduleValidator: Permit .gitmodules file with missing path or url instead of throwing NullPointerException<\/p>\n<\/li>\n<li>\n<p>ssh: Prefer algorithms of the known host keys<\/p>\n<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>SubmoduleValidator: Permit .gitmodules file with missing path or url&nbsp;instead of throwing NullPointerException<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>ssh: Prefer algorithms of the known host keys<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\n<\/li>\n<li>\n<p>SubmoduleValidator: Permit .gitmodules file with missing path or url instead of throwing NullPointerException<\/p>\n<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Replace FindBugs with SpotBugs (downported)<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>SubmoduleValidator: Permit .gitmodules file with missing path or url&nbsp;instead of throwing NullPointerException<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace FindBugs with SpotBugs (downported)<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.5","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\n<\/li>\n<li>\n<p>SubmoduleValidator: Permit .gitmodules file with missing path or url instead of throwing NullPointerException<\/p>\n<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Replace FindBugs with SpotBugs (downported)<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>SubmoduleValidator: Permit .gitmodules file with missing path or url&nbsp;instead of throwing NullPointerException<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace FindBugs with SpotBugs (downported)<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.7","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li>\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\n<\/li>\n<li>\n<p>SubmoduleValidator: Permit .gitmodules file with missing path or url instead of throwing NullPointerException<\/p>\n<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Replace FindBugs with SpotBugs (downported)<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=540049\">540049<\/a> Fix file handle leak in ObjectDownloadListener.onWritePossible<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p>SubmoduleValidator: Permit .gitmodules file with missing path or url&nbsp;instead of throwing NullPointerException<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Replace FindBugs with SpotBugs (downported)<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.6","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-06 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive \"git clone\" of a superproject if a .gitmodules file has a URL field beginning with a '-' character.<\/p>\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\n<ul><li>BaseReceivePack: Validate incoming .gitmodules files and reject submodule urls starting with '-' that could pass as options to an unguarded tool<\/li>\n<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\n<li>SubmoduleAddCommand: Reject submodule URIs that look like command line options<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Fix configuration of maven-javadoc-plugin<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\r\n\r\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive &quot;git clone&quot; of a superproject if a .gitmodules file has a URL field beginning with a &#39;-&#39; character.<\/p>\r\n\r\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\r\n\r\n<ul>\r\n\t<li>BaseReceivePack: Validate incoming .gitmodules files and reject&nbsp;submodule urls starting with &#39;-&#39; that could pass as&nbsp;options to an unguarded tool<\/li>\r\n\t<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\r\n\t<li>SubmoduleAddCommand: Reject submodule URIs that look like command line&nbsp;options<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix configuration of maven-javadoc-plugin<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-06 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive \"git clone\" of a superproject if a .gitmodules file has a URL field beginning with a '-' character.<\/p>\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\n<ul><li>BaseReceivePack: Validate incoming .gitmodules files and reject submodule urls starting with '-' that could pass as options to an unguarded tool<\/li>\n<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\n<li>SubmoduleAddCommand: Reject submodule URIs that look like command line options<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Fix configuration of maven-javadoc-plugin<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\r\n\r\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive &quot;git clone&quot; of a superproject if a .gitmodules file has a URL field beginning with a &#39;-&#39; character.<\/p>\r\n\r\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\r\n\r\n<ul>\r\n\t<li>BaseReceivePack: Validate incoming .gitmodules files and reject&nbsp;submodule urls starting with &#39;-&#39; that could pass as&nbsp;options to an unguarded tool<\/li>\r\n\t<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\r\n\t<li>SubmoduleAddCommand: Reject submodule URIs that look like command line&nbsp;options<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix configuration of maven-javadoc-plugin<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.4","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.4","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-06 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive \"git clone\" of a superproject if a .gitmodules file has a URL field beginning with a '-' character.<\/p>\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\n<ul><li>BaseReceivePack: Validate incoming .gitmodules files and reject submodule urls starting with '-' that could pass as options to an unguarded tool<\/li>\n<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\n<li>SubmoduleAddCommand: Reject submodule URIs that look like command line options<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\r\n\r\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive &quot;git clone&quot; of a superproject if a .gitmodules file has a URL field beginning with a &#39;-&#39; character.<\/p>\r\n\r\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\r\n\r\n<ul>\r\n\t<li>BaseReceivePack: Validate incoming .gitmodules files and reject&nbsp;submodule urls starting with &#39;-&#39; that could pass as&nbsp;options to an unguarded tool<\/li>\r\n\t<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\r\n\t<li>SubmoduleAddCommand: Reject submodule URIs that look like command line&nbsp;options<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.6","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-10-06 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive \"git clone\" of a superproject if a .gitmodules file has a URL field beginning with a '-' character.<\/p>\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\n<ul><li>BaseReceivePack: Validate incoming .gitmodules files and reject submodule urls starting with '-' that could pass as options to an unguarded tool<\/li>\n<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\n<li>SubmoduleAddCommand: Reject submodule URIs that look like command line options<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<p><a href=\"https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17456\">CVE-2018-17456<\/a><\/p>\r\n\r\n<p>Git before 2.14.5, 2.15.x before 2.15.3, 2.16.x before 2.16.5, 2.17.x before 2.17.2, 2.18.x before 2.18.1, and 2.19.x before 2.19.1 allows remote code execution during processing of a recursive &quot;git clone&quot; of a superproject if a .gitmodules file has a URL field beginning with a &#39;-&#39; character.<\/p>\r\n\r\n<p>JGit itself is not affected by this vulnerability. This release implements validation of .gitmodules files in JGit to protect unguarded tools.<\/p>\r\n\r\n<ul>\r\n\t<li>BaseReceivePack: Validate incoming .gitmodules files and reject&nbsp;submodule urls starting with &#39;-&#39; that could pass as&nbsp;options to an unguarded tool<\/li>\r\n\t<li>ObjectChecker: Report .gitmodules files found in the pack<\/li>\r\n\t<li>SubmoduleAddCommand: Reject submodule URIs that look like command line&nbsp;options<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.5","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a> Fix async IO used in FileLfsServlet\n<ul><li>Fix ObjectUploadListener#close<\/li>\n<li>Fix error handling in FileLfsServlet<\/li>\n<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<\/li>\n<\/ul><h2>Build and release engineering<\/h2>\n<ul><li>Update japicmp to 0.13.0<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a>&nbsp;Fix async IO used in FileLfsServlet\r\n\r\n\t<ul>\r\n\t\t<li>Fix ObjectUploadListener#close<\/li>\r\n\t\t<li>Fix error handling in FileLfsServlet<\/li>\r\n\t\t<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and release engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Update japicmp to 0.13.0<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-19 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release will be shipped with the simultaneous release 2018-09<\/p>\n<p>Features<\/p>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=434085\">434085<\/a> Use the same default diff.renameLimit = 400 like native git<\/li>\n<li>Parse signature of GPG-signed commits<\/li>\n<li>Replace fetch.useminimalnegotation flag with fetch.maxhaves flag<\/li>\n<li>Protocol V2\n<ul><li>FetchV2Request: Rename shallowSince to deepenSince<\/li>\n<li>Add fetch support to ProtocolV2Hook<\/li>\n<li>#534847 Introduce ProtocolV2Hook<\/li>\n<li>Fetch protocol v2: Respond with shallow-info before wanted-refs<\/li>\n<li>Support protocol v2 want-ref in UploadPack<\/li>\n<\/ul><\/li>\n<li>Allow overriding DfsPackDescription comparator for scanning packs<\/li>\n<li>Make DfsConfig public<\/li>\n<li>Add ls-files CLI command<\/li>\n<li>RepoCommand: Support remove-project node in the manifest parser<\/li>\n<li>RepoCommand: record remote branch, group, shallow bit by default<\/li>\n<li>SubmoduleAddCommand: Add API to specify the submodule name<\/li>\n<\/ul><p>Performance Improvements<\/p>\n<ul><li>Seek references by prefix in reftable<\/li>\n<li>Fix a GC scalability issue when selecting commit bitmaps<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=485743\">485743<\/a> Avoid expensive getAllRefsByPeeledObjectId() in PlotWalk constructor<\/li>\n<\/ul><p>Bug Fixes<\/p>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536318\">536318<\/a> Fix replacement quoting for replaceAll in filter command<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\n<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538286\">538286<\/a> Fix NoSuchFileException in GC.deleteTempPacksIdx()<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a> Fix fetching with duplicate ref updates<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a> Fetch(Process): should tolerate duplicate refspecs<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538068\">538068<\/a> SubmoduleDeinitTest fails on Windows<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538068\">538068<\/a> FilterCommandsTest fails on Windows<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538068\">538068<\/a> ReceivePackAdvertiseRefsHookTest.testSuccess() fails on Windows<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix wrong warning message in case of lock failures<\/li>\n<li>Fix GC run in foreground to not use executor<\/li>\n<li>Fix unpredictable ordering of entries in .gitmodules.<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537410\">537410<\/a> Fix ResolveMerger: rebase with autocrlf=true, direct checkout<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537790\">537790<\/a> Ensure that JSch knows HostKeyAlgorithms ssh-rsa and ssh-dss<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536324\">536324<\/a> Abort rename detection in a timely manner if cancelled<\/li>\n<li>RepoCommand: Use project names instead of paths for the submodule name<\/li>\n<li>Send only 1 flush pkt at the end of v2 fetch<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=499543\">499543<\/a> Fix NPE in BlameGenerator.getSourceStart()<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537166\">537166<\/a> HttpClientConnection.getHeaderFields should support multiple values for same header<\/li>\n<li>Always send refs' objects despite \"filter\" in pack<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536880\">536880<\/a> ResolveMerger: don't try needlessly to delete directories<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Ensure RacyGitTests don't raise false negatives<\/li>\n<li>GC: Trim more EWAHCompressedBitmaps to free unused memory<\/li>\n<li>Make Reftable seek* and has* method names more consistent<\/li>\n<li>Add progress monitor step to first phase of GC commit selection<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536541\">536541<\/a> Add response message, if any, on HTTP status 404<\/li>\n<li>Correctly handle initialization of shallow commits<\/li>\n<li>CleanCommand: don't fire WorkingTreeModifiedEvent on dry run<\/li>\n<li>DfsPackDescription: Disallow null PackSource<\/li>\n<\/ul><p>Build and Release Engineering<\/p>\n<ul><li>Update Orbit 2018-09 to R20180905201904<\/li>\n<li>Update Photon orbit repository to R20180606145124<\/li>\n<li>Bazel: Use hyphen instead of underscore in external repository names<\/li>\n<li>Update bazel dependencies to match maven dependencies<\/li>\n<li>Update Jetty to 9.4.11.v20180605<\/li>\n<li>Update org.apache.commons.codec to 1.10.0.v20180409-1845<\/li>\n<li>Update org.apache.commons.logging to 1.2.0.v20180409-1502<\/li>\n<li>Update org.apache.httpcomponents.httpclient to 4.5.5.v20180409-1525<\/li>\n<li>Update org.apache.httpcomponents.httpcore to 4.4.9.v20180409-1525<\/li>\n<li>Update Maven plugins\n<ul><li>build-helper-maven-plugin 3.0.0<\/li>\n<li>eclipse-jarsigner-plugin 1.1.5<\/li>\n<li>jacoco-maven-plugin 0.8.1<\/li>\n<li>maven-clean-plugin 3.1.0<\/li>\n<li>maven-compiler-plugin 3.8.0<\/li>\n<li>maven-jar-plugin 3.1.2<\/li>\n<li>maven-pmd-plugin 3.10.0<\/li>\n<li>maven-resources-plugin 3.1.0<\/li>\n<li>maven-shade-plugin 3.1.1<\/li>\n<li>maven-site-plugin 3.7.1<\/li>\n<li>maven-surefire-plugin 2.21.0<\/li>\n<li>maven-surefire-report-plugin 2.21.0<\/li>\n<li>plexus-compiler-javac 2.8.4<\/li>\n<li>spotbugs-maven-plugin 3.1.6<\/li>\n<li>wagon-ssh 3.1.0<\/li>\n<\/ul><\/li>\n<li>Upgrade Tycho to 1.2.0<\/li>\n<\/ul>","summary":"","value":"<p>This release will be shipped with the simultaneous release 2018-09<\/p>\r\n\r\n<h1>Features<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=434085\">434085<\/a> Use the same default diff.renameLimit = 400 like native git<\/li>\r\n\t<li>Parse signature of GPG-signed commits<\/li>\r\n\t<li>Replace fetch.useminimalnegotation flag with fetch.maxhaves flag<\/li>\r\n\t<li>Protocol V2\r\n\t<ul>\r\n\t\t<li>FetchV2Request: Rename shallowSince to deepenSince<\/li>\r\n\t\t<li>Add fetch support to ProtocolV2Hook<\/li>\r\n\t\t<li>#534847 Introduce ProtocolV2Hook<\/li>\r\n\t\t<li>Fetch protocol v2: Respond with shallow-info before wanted-refs<\/li>\r\n\t\t<li>Support protocol v2 want-ref in UploadPack<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Allow overriding DfsPackDescription comparator for scanning packs<\/li>\r\n\t<li>Make DfsConfig public<\/li>\r\n\t<li>Add ls-files CLI command<\/li>\r\n\t<li>RepoCommand: Support remove-project node in the manifest parser<\/li>\r\n\t<li>RepoCommand: record remote branch, group, shallow bit by default<\/li>\r\n\t<li>SubmoduleAddCommand: Add API to specify the submodule name<\/li>\r\n<\/ul>\r\n\r\n<h1>Performance Improvements<\/h1>\r\n\r\n<ul>\r\n\t<li>Seek references by prefix in reftable<\/li>\r\n\t<li>Fix a GC scalability issue when selecting commit bitmaps<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=485743\">485743<\/a> Avoid expensive getAllRefsByPeeledObjectId() in PlotWalk constructor<\/li>\r\n<\/ul>\r\n\r\n<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536318\">536318<\/a> Fix replacement quoting for replaceAll in filter command<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\r\n\t<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538286\">538286<\/a> Fix NoSuchFileException in GC.deleteTempPacksIdx()<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a> Fix fetching with duplicate ref updates<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a> Fetch(Process): should tolerate duplicate refspecs<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538068\">538068<\/a> SubmoduleDeinitTest fails on Windows<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538068\">538068<\/a> FilterCommandsTest fails on Windows<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538068\">538068<\/a> ReceivePackAdvertiseRefsHookTest.testSuccess() fails on Windows<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix wrong warning message in case of lock failures<\/li>\r\n\t<li>Fix GC run in foreground to not use executor<\/li>\r\n\t<li>Fix unpredictable ordering of entries in .gitmodules.<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537410\">537410<\/a> Fix ResolveMerger: rebase with autocrlf=true, direct checkout<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537790\">537790<\/a> Ensure that JSch knows HostKeyAlgorithms ssh-rsa and ssh-dss<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536324\">536324<\/a> Abort rename detection in a timely manner if cancelled<\/li>\r\n\t<li>RepoCommand: Use project names instead of paths for the submodule name<\/li>\r\n\t<li>Send only 1 flush pkt at the end of v2 fetch<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=499543\">499543<\/a> Fix NPE in BlameGenerator.getSourceStart()<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537166\">537166<\/a> HttpClientConnection.getHeaderFields should support multiple values for same header<\/li>\r\n\t<li>Always send refs&#39; objects despite &quot;filter&quot; in pack<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536880\">536880<\/a> ResolveMerger: don&#39;t try needlessly to delete directories<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526111\">526111<\/a> Ensure RacyGitTests don&#39;t raise false negatives<\/li>\r\n\t<li>GC: Trim more EWAHCompressedBitmaps to free unused memory<\/li>\r\n\t<li>Make Reftable seek* and has* method names more consistent<\/li>\r\n\t<li>Add progress monitor step to first phase of GC commit selection<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536541\">536541<\/a> Add response message, if any, on HTTP status 404<\/li>\r\n\t<li>Correctly handle initialization of shallow commits<\/li>\r\n\t<li>CleanCommand: don&#39;t fire WorkingTreeModifiedEvent on dry run<\/li>\r\n\t<li>DfsPackDescription: Disallow null PackSource<\/li>\r\n<\/ul>\r\n\r\n<h1>Build and Release Engineering<\/h1>\r\n\r\n<ul>\r\n\t<li>Update Orbit 2018-09 to R20180905201904<\/li>\r\n\t<li>Update Photon orbit repository to R20180606145124<\/li>\r\n\t<li>Bazel: Use hyphen instead of underscore in external repository names<\/li>\r\n\t<li>Update bazel dependencies to match maven dependencies<\/li>\r\n\t<li>Update Jetty to 9.4.11.v20180605<\/li>\r\n\t<li>Update org.apache.commons.codec to 1.10.0.v20180409-1845<\/li>\r\n\t<li>Update org.apache.commons.logging to 1.2.0.v20180409-1502<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpclient to 4.5.5.v20180409-1525<\/li>\r\n\t<li>Update org.apache.httpcomponents.httpcore to 4.4.9.v20180409-1525<\/li>\r\n\t<li>Update Maven plugins\r\n\t<ul>\r\n\t\t<li>build-helper-maven-plugin 3.0.0<\/li>\r\n\t\t<li>eclipse-jarsigner-plugin 1.1.5<\/li>\r\n\t\t<li>jacoco-maven-plugin 0.8.1<\/li>\r\n\t\t<li>maven-clean-plugin 3.1.0<\/li>\r\n\t\t<li>maven-compiler-plugin 3.8.0<\/li>\r\n\t\t<li>maven-jar-plugin 3.1.2<\/li>\r\n\t\t<li>maven-pmd-plugin 3.10.0<\/li>\r\n\t\t<li>maven-resources-plugin 3.1.0<\/li>\r\n\t\t<li>maven-shade-plugin 3.1.1<\/li>\r\n\t\t<li>maven-site-plugin 3.7.1<\/li>\r\n\t\t<li>maven-surefire-plugin 2.21.0<\/li>\r\n\t\t<li>maven-surefire-report-plugin 2.21.0<\/li>\r\n\t\t<li>plexus-compiler-javac 2.8.4<\/li>\r\n\t\t<li>spotbugs-maven-plugin 3.1.6<\/li>\r\n\t\t<li>wagon-ssh 3.1.0<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Upgrade Tycho to 1.2.0<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-19 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.1.0"}],"state":[{"value":"success"}],"title":"5.1.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.1.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.1.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a> Fix async IO used in FileLfsServlet\n<ul><li>Fix ObjectUploadListener#close<\/li>\n<li>Fix error handling in FileLfsServlet<\/li>\n<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a>&nbsp;Fix async IO used in FileLfsServlet\r\n\r\n\t<ul>\r\n\t\t<li>Fix ObjectUploadListener#close<\/li>\r\n\t\t<li>Fix error handling in FileLfsServlet<\/li>\r\n\t\t<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a> Fix async IO used in FileLfsServlet\n<ul><li>Fix ObjectUploadListener#close<\/li>\n<li>Fix error handling in FileLfsServlet<\/li>\n<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a>&nbsp;Fix async IO used in FileLfsServlet\r\n\r\n\t<ul>\r\n\t\t<li>Fix ObjectUploadListener#close<\/li>\r\n\t\t<li>Fix error handling in FileLfsServlet<\/li>\r\n\t\t<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.5","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a> Fix async IO used in FileLfsServlet\n<ul><li>Fix ObjectUploadListener#close<\/li>\n<li>Fix error handling in FileLfsServlet<\/li>\n<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\n<\/ul><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9667\">gerrit 9667<\/a>, <a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9721\">gerrit 9721<\/a>, <a href=\"https:\/\/github.com\/eclipse\/jetty.project\/issues\/2911\">jetty 2911<\/a>&nbsp;Fix async IO used in FileLfsServlet\r\n\r\n\t<ul>\r\n\t\t<li>Fix ObjectUploadListener#close<\/li>\r\n\t\t<li>Fix error handling in FileLfsServlet<\/li>\r\n\t\t<li>ObjectDownloadListener#onWritePossible: Make code spec compatible<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531759\">531759<\/a> Fix IOException when LockToken#close fails<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538285\">538285<\/a> Fix NoSuchFileException during directory cleanup in RefDirectory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning for trying to delete non-empty directory<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.4","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.4","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-10 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\n<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\n<li>Fix GC run in foreground to not use executor<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning which was logged when 'fetch --prune' with a stale remote branch tries to delete non-empty directory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a> Fix fetching with duplicate ref updates<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a> Fetch(Process): should tolerate duplicate refspecs<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Fix photon target platform to use photon version of org.eclipse.osgi<\/li>\n<li>Update Photon orbit repository to R20180606145124<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a>&nbsp;Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\r\n\t<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\r\n\t<li>Fix GC run in foreground to not use executor<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a>&nbsp;Suppress warning which was logged when &#39;fetch --prune&#39;&nbsp;with a stale remote branch tries to delete non-empty directory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a>&nbsp;Fix fetching with duplicate ref updates<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a>&nbsp;Fetch(Process): should tolerate duplicate refspecs<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix photon target platform to use photon version of org.eclipse.osgi<\/li>\r\n\t<li>Update Photon orbit repository to R20180606145124<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-09 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p> <\/p>\n<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix wrong warning message in case of lock failures<\/li>\n<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538286\">538286<\/a> Fix NoSuchFileException in GC.deleteTempPacksIdx() which was thrown if the repository has no packs<\/li>\n<li>Fix GC run in foreground to not use executor<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536285\">538285<\/a> Fix NoSuchFileException during cleanup of empty ref directories in RefDirectory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning which was logged when 'fetch --prune' with a stale remote branch tries to delete non-empty directory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a> Fix fetching with duplicate ref updates<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a> Fetch(Process): should tolerate duplicate refspecs<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537790\">537790<\/a> Ensure that JSch knows HostKeyAlgorithms ssh-rsa and ssh-dss<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Fix photon target platform to use photon version of org.eclipse.osgi<\/li>\n<li>Update Photon orbit repository to R20180606145124<\/li>\n<\/ul>","summary":"","value":"<p>&nbsp;<\/p>\r\n\r\n<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a>&nbsp;Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix wrong warning message in case of lock failures<\/li>\r\n\t<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=538286\">538286<\/a> Fix NoSuchFileException in GC.deleteTempPacksIdx() which was thrown if the repository has no packs<\/li>\r\n\t<li>Fix GC run in foreground to not use executor<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536285\">538285<\/a> Fix NoSuchFileException during cleanup of empty ref directories in RefDirectory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a>&nbsp;Suppress warning which was logged when &#39;fetch --prune&#39;&nbsp;with a stale remote branch tries to delete non-empty directory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a>&nbsp;Fix fetching with duplicate ref updates<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a>&nbsp;Fetch(Process): should tolerate duplicate refspecs<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537790\">537790<\/a> Ensure that JSch knows HostKeyAlgorithms ssh-rsa and ssh-dss<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix photon target platform to use photon version of org.eclipse.osgi<\/li>\r\n\t<li>Update Photon orbit repository to R20180606145124<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.0.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.0.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-09 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\n<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\n<li>Fix GC run in foreground to not use executor<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning which was logged when fetching with option --prune with a stale remote branch tries to delete non-empty directory<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a> Fix fetching with duplicate ref updates<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a> Fetch(Process): should tolerate duplicate refspecs<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Fix photon target platform to use photon version of org.eclipse.osgi<\/li>\n<li>Update Photon orbit repository to R20180606145124<\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\r\n\t<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\r\n\t<li>Fix GC run in foreground to not use executor<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537872\">537872<\/a> Suppress warning which was logged when fetching with option --prune with a stale remote branch tries to delete non-empty directory<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529400\">529400<\/a> Fix fetching with duplicate ref updates<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529314\">529314<\/a> Fetch(Process): should tolerate duplicate refspecs<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix photon target platform to use photon version of org.eclipse.osgi<\/li>\r\n\t<li>Update Photon orbit repository to R20180606145124<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.4","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.4","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-09 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug Fixes<\/h2>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\n<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\n<li>Fix GC run in foreground to not use executor<br \/>\n\t <\/li>\n<\/ul>","summary":"","value":"<h2>Bug Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=537969\">537969<\/a> Fix atomic lock file creation on NFS configured via option core.supportsAtomicCreateNewFile<\/li>\r\n\t<li>GC: Avoid logging errors when deleting non-empty folders<\/li>\r\n\t<li>Fix GC run in foreground to not use executor<br \/>\r\n\t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-07-31 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug fixes<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a> Delete empty refs directories<\/li>\n<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\n<li>Fix maven site generation failing with javadoc errors<\/li>\n<li>Respect \"unshallow\" lines in protocol v2<\/li>\n<\/ul>","summary":"","value":"<h2>Bug fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a>&nbsp;Delete empty refs directories<\/li>\r\n\t<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\r\n\t<li>Fix maven site generation failing with javadoc errors<\/li>\r\n\t<li>Respect &quot;unshallow&quot; lines in protocol v2<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.0.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.0.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-07-31 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug fixes<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a> Delete empty refs directories<\/li>\n<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\n<li>ObjectIdSerializer: Support serialization of known non-null ObjectId<\/li>\n<li>Ensure DirectoryStream is closed promptly in GC#deleteTempPacksIdx<\/li>\n<li>Retry when stale file handles on .git\/config file cause read errors when the config file is replaced by another process<\/li>\n<li>LFS: Fix potential NPE in LfsPrePushHook<\/li>\n<li>ObjectIdSerializer: Support serialization of known non-null ObjectId<\/li>\n<\/ul>","summary":"","value":"<h2>Bug fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a>&nbsp;Delete empty refs directories<\/li>\r\n\t<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\r\n\t<li>ObjectIdSerializer: Support serialization of known non-null ObjectId<\/li>\r\n\t<li>Ensure DirectoryStream is closed promptly in GC#deleteTempPacksIdx<\/li>\r\n\t<li>Retry when stale file handles on .git\/config file cause read errors when the config file is replaced by another process<\/li>\r\n\t<li>LFS: Fix potential NPE in LfsPrePushHook<\/li>\r\n\t<li>ObjectIdSerializer: Support serialization of known non-null ObjectId<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-07-31 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug fixes<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a> Delete empty refs directories<\/li>\n<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\n<li>Ensure DirectoryStream is closed promptly in GC#deleteTempPacksIdx<\/li>\n<li>Retry when stale file handles on .git\/config file cause read errors when the config file is replaced by another process<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531118\">#531118<\/a> Fix ssh host name handling for Jsch<\/li>\n<li>Fix that Jsch overrides the port in the URI with the one in ~\/.ssh\/config<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529173\">#529173<\/a> Revert handling of ssh IdentityFile to pre-4.9 behavior<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528886\">#528886<\/a> Strings#convertGlob: fix incorrect attributes pattern matching in case of brackets inside brackets<\/li>\n<li>PackInserter: Ensure objects are written at the end of the pack<\/li>\n<li>Do not ignore path deletion errors but log as warning when an attempt to remove a directory fails.<\/li>\n<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9153\">Gerrit bug #9153<\/a> Fix LockFile semantics when running on NFS<\/li>\n<li>Honor trustFolderStats also when reading packed-refs<\/li>\n<li>Fix exception handling for opening bitmap index files when index file was deleted by gc run in another process<\/li>\n<\/ul>","summary":"","value":"<h2>Bug fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a>&nbsp;Delete empty refs directories<\/li>\r\n\t<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\r\n\t<li>Ensure DirectoryStream is closed promptly in GC#deleteTempPacksIdx<\/li>\r\n\t<li>Retry when stale file handles on .git\/config file cause read errors when the config file is replaced by another process<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531118\">#531118<\/a> Fix ssh host name handling for Jsch<\/li>\r\n\t<li>Fix that Jsch overrides the port in the URI with the one in ~\/.ssh\/config<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529173\">#529173<\/a> Revert handling of ssh IdentityFile to pre-4.9 behavior<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528886\">#528886<\/a>&nbsp;Strings#convertGlob: fix incorrect attributes pattern matching in case of brackets inside brackets<\/li>\r\n\t<li>PackInserter: Ensure objects are written at the end of the pack<\/li>\r\n\t<li>Do not ignore path deletion errors but log as warning when an attempt to remove a directory fails.<\/li>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9153\">Gerrit bug #9153<\/a> Fix LockFile semantics when running on NFS<\/li>\r\n\t<li>Honor trustFolderStats also when reading packed-refs<\/li>\r\n\t<li>Fix exception handling for opening bitmap index files when index file was deleted by gc run in another process<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-07-26 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Bug fixes<\/h2>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a> Delete empty refs directories<\/li>\n<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\n<li>Retry when stale file handles on .git\/config file cause read errors when the config file is replaced by another process<\/li>\n<li>Do not ignore path deletion errors but log as warning when an attempt to remove a directory fails.<\/li>\n<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9153\">Gerrit bug #9153<\/a> Fix LockFile semantics when running on NFS<\/li>\n<li>Honor trustFolderStats also when reading packed-refs<\/li>\n<li>Fix exception handling for opening bitmap index files when index file was deleted by gc run in another process<\/li>\n<\/ul>","summary":"","value":"<h2>Bug fixes<\/h2>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">#<\/a><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536777\">536777<\/a>&nbsp;Delete empty refs directories<\/li>\r\n\t<li>ResolveMerger: Fix encoding with string; use bytes<\/li>\r\n\t<li>Retry when stale file handles on .git\/config file cause read errors when the config file is replaced by another process<\/li>\r\n\t<li>Do not ignore path deletion errors but log as warning when an attempt to remove a directory fails.<\/li>\r\n\t<li><a href=\"https:\/\/bugs.chromium.org\/p\/gerrit\/issues\/detail?id=9153\">Gerrit bug #9153<\/a> Fix LockFile semantics when running on NFS<\/li>\r\n\t<li>Honor trustFolderStats also when reading packed-refs<\/li>\r\n\t<li>Fix exception handling for opening bitmap index files when index file was deleted by gc run in another process<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-06-27 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<ul><li>API cleanup<\/li>\n<li>remove deprecated APIs<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526500\">migrate from File to Path<\/a><\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526497\">Config methods should throw checked Exceptions instead of IllegalArgumentExceptions<\/a><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>API cleanup<\/li>\r\n\t<li>remove deprecated APIs<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526500\">migrate from File to Path<\/a><\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526497\">Config methods should throw checked Exceptions instead of IllegalArgumentExceptions<\/a><\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Features<\/p>\n<ul><li>Fetch: Basic support for protocol v2 of the fetch-pack\/upload-pack protocol. This protocol is described in the Git project in \"<a href=\"https:\/\/github.com\/git\/git\/blob\/master\/Documentation\/technical\/protocol-v2.txt\">Documentation\/technical\/protocol-v2.txt<\/a>\".<br \/>\n\tNotes:<br \/>\n\t- <a href=\"https:\/\/bugs.eclipse.org\/534847\">534847<\/a> AdvertiseRefsHook is not executed for v2, to be replaced by an appropriate hook<br \/>\n\t- <a href=\"https:\/\/git.eclipse.org\/r\/#\/c\/120007\/\">change120007<\/a> support for shallow fetch using protocol v2 is not complete<\/li>\n<li>Add protocol v2 support in jgit daemon<br \/>\n\tWith this patch, a server spawned by jgit daemon can be accessed using protocol v2 from a Git client that supports it (for example, \"git\" with the appropriate patches, to be released with git 2.18). This is only activated if the repository's config has \"protocol.version\" be 2.<\/li>\n<li>Store in IndexChangedEvent if it was caused by JGit itself<br \/>\n\tThis allows to differentiate if index was changed by an external git command or by JGit itself.<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/358206\">358206<\/a> Handle Gerrit Change-Ids for merge commits<\/li>\n<li>UploadPack: basic support for filtering by blob size. This is incomplete in that the filter-by-sparse-specification feature also supported by Git is not included yet.<\/li>\n<li>Implement --force option in FetchCommand and CLI fetch command<\/li>\n<\/ul><p>Performance Improvements<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/388582\">388582<\/a> Skip ignored directories in FileTreeIterator<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/532300\">532300<\/a> Significantly speed up FileTreeIterator on Windows<\/li>\n<li>Configure WindowCache settings to use in JGit CLI.<br \/>\n\tSet the same defaults as in EGit. Use mmap to map git packfiles into memory. Avoids allocating JGit buffer cache on the Java heap.<\/li>\n<\/ul><p>Fixes<\/p>\n<ul><li><a href=\"http:\/\/bugs.eclipse.org\/423206\">423206<\/a> Make JGit describe behaves same as c-git for lightweight tags<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/535672\">535672<\/a> Ensure Jsch checks all configured algorithms<\/li>\n<li><a href=\"http:\/\/bugs.eclipse.org\/535655\">535655<\/a> Validate branch names on branch creation<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/533549\">533549<\/a> Don't prune symbolic refs when fetch.prune = true<\/li>\n<li>Use a secure random generator to seed nonce for digest authentication<\/li>\n<li>Retry stale NFS file handles on .git\/config file (https:\/\/git.eclipse.org\/r\/#\/c\/120973\/)<\/li>\n<li><a href=\"https:\/\/bugs.eclipse.org\/529463\">529463<\/a> ssh: Kill the external process when we're done instead of waiting forever<\/li>\n<li>Allow '@' as last character of ref. Previously @ was allowed e.g. in branch names, but not as the last character.<\/li>\n<li>Don't throw an exception if a pre-push hook is ignored.<\/li>\n<li>LFS: Fix potential NPE in LfsPrePushHook<\/li>\n<li>FS#runProcess: Fix OutputStream left unclosed after IOException<\/li>\n<\/ul><p>Incompatible Changes<\/p>\n<ul><li>Remove deprecated Repository#notifyIndexChanged<br \/>\n\tImplementors should now override Repository#notifyIndexChanged(boolean)<\/li>\n<li>Remove deprecated LfsProtocolServlet#getLargeFileRepository<br \/>\n\tUse LfsProtocolServlet##getLargeFileRepository(LfsRequest, String, String) instead.<\/li>\n<li>Remove deprecated Lfs#Lfs(Path)<br \/>\n\tUse Lfs#Lfs(Repository) instead.<\/li>\n<li>Remove deprecated StreamCopyThread#flush<\/li>\n<li>Remove deprecated SafeBufferedOutputStream<br \/>\n\tUse Java 8 BufferedOutputStream instead.<\/li>\n<li>Remove deprecated EolCanonicalizingInputStream<br \/>\n\tUse AutoLFInputStream instead.<\/li>\n<li>Remove deprecated FileUtils#relativize(String, String)<br \/>\n\tUse the more-clearly-named FileUtils#relativizeNativePath(String, String) instead, or directly call FileUtils#relativizePath(String, String, String, boolean).<\/li>\n<li>Remove deprecated FileUtil using Java 7 NIO<\/li>\n<li>Remove deprecated TreeWalk#getEolStreamType<br \/>\n\tUse TreeWalk#getEolStreamType(OperationType) instead.<\/li>\n<li>Remove deprecated FileTreeIterator(WorkingTreeIterator, File, FS)<br \/>\n\tUse FileTreeIterator#FileTreeIterator(FileTreeIterator, File, FS) instead.<\/li>\n<li>Remove deprecated TransportHttp#httpOpen(String, URL)<br \/>\n\tUse TransportHttp#httpOpen(String, URL, AcceptEncoding) instead.<\/li>\n<li>Remove deprecated ResolveMerger#processEntry method<\/li>\n<li>Remove deprecated Repository#getRef<br \/>\n\tUse Repository#exactRef(String) or Repository#findRef(String) instead.<\/li>\n<li>Remove deprecated BitmapBuilder#add<br \/>\n\tUse BitmapBuilder#or or BitmapBuilder#addObject instead.<\/li>\n<li>Remove deprecated LockFile(File, FS) constructor<br \/>\n\tUse org.eclipse.jgit.internal.storage.file.LockFile#LockFile(File) instead.<\/li>\n<li>Remove deprecated IgnoreNode#isIgnored method<br \/>\n\tParameter negateFirstMatch is not honored anymore<\/li>\n<li>Remove deprecated Statistics, UploadPackLogger, UploadPackLoggerChain<br \/>\n\tUse PackStatistics and PostUploadHook and PostUploadHookChain instead.<\/li>\n<li>Remove UploadPack#getPackStatistics<br \/>\n\tUse #getStatistics instead<\/li>\n<li>Remove UploadPack#getLogger and UploadPack#setLogger<\/li>\n<li>Remove deprecated StoredObjectRepresentationnotAvailableException ctor<br \/>\n\tUse #StoredObjectRepresentationNotAvailableException(ObjectToPack, Throwable) instead.<\/li>\n<li>Remove deprecated ArchiveCommand#putEntry method<br \/>\n\tUse #putEntry(Closeable, ObjectId, String, FileMode, ObjectLoader)} instead.<\/li>\n<li>Fix misspelled class name: EmtpyCommitException -&gt; EmptyCommitException<\/li>\n<li>RemoteAddCommand#setName(String) and #setUri(URIish): return RemoteAddCommand to allow chaining.<\/li>\n<\/ul><p>Build and Release Engineering<\/p>\n<ul><li>Update to latest Photon Orbit R20180606145124<\/li>\n<li>Update maven plugins to fix Zip Slip vulnerability<\/li>\n<li>Bazel: Add a target to build jgit commandline tool<\/li>\n<li>Use eclipse compiler in Maven build. Define profiles \"ecj\" for using Eclipse compiler and \"javac\" for using javac including errorprone. By default ecj will be used.<\/li>\n<li>Upgrade error_prone_core to 2.3.1<\/li>\n<li>Update SUA to current version.<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h1>Features<\/h1>\r\n\r\n<ul>\r\n\t<li>Fetch: Basic support for protocol v2 of the fetch-pack\/upload-pack protocol. This protocol is described in the Git project in &quot;<a href=\"https:\/\/github.com\/git\/git\/blob\/master\/Documentation\/technical\/protocol-v2.txt\">Documentation\/technical\/protocol-v2.txt<\/a>&quot;.<br \/>\r\n\tNotes:<br \/>\r\n\t- <a href=\"https:\/\/bugs.eclipse.org\/534847\">534847<\/a>&nbsp;AdvertiseRefsHook is not executed for v2, to be replaced by an appropriate hook<br \/>\r\n\t- <a href=\"https:\/\/git.eclipse.org\/r\/#\/c\/120007\/\">change120007<\/a>&nbsp;support for shallow fetch using protocol v2 is not complete<\/li>\r\n\t<li>Add protocol v2 support in jgit daemon<br \/>\r\n\tWith this patch, a server spawned by jgit daemon&nbsp;can be accessed using protocol v2 from a Git client that supports it (for example, &quot;git&quot; with the appropriate patches, to be released with git 2.18). This is only activated if the repository&#39;s config has &quot;protocol.version&quot; be 2.<\/li>\r\n\t<li>Store in IndexChangedEvent if it was caused by JGit itself<br \/>\r\n\tThis allows to differentiate if index was changed by an external git command or by JGit itself.<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/358206\">358206<\/a>&nbsp;Handle Gerrit Change-Ids for merge commits<\/li>\r\n\t<li>UploadPack: basic support for&nbsp;filtering by blob size. This is incomplete in that the filter-by-sparse-specification feature also supported by Git is not included yet.<\/li>\r\n\t<li>Implement --force option in FetchCommand and CLI fetch command<\/li>\r\n<\/ul>\r\n\r\n<h1>Performance Improvements<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/388582\">388582<\/a>&nbsp;Skip ignored directories in FileTreeIterator<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/532300\">532300<\/a>&nbsp;Significantly speed up FileTreeIterator on Windows<\/li>\r\n\t<li>Configure WindowCache settings to use in JGit CLI.<br \/>\r\n\tSet the same defaults as in EGit. Use mmap to map git packfiles into memory. Avoids allocating JGit buffer&nbsp;cache on the Java heap.<\/li>\r\n<\/ul>\r\n\r\n<h1>Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/423206\">423206<\/a> Make JGit describe behaves same as c-git for lightweight tags<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/535672\">535672<\/a> Ensure Jsch checks all configured algorithms<\/li>\r\n\t<li><a href=\"http:\/\/bugs.eclipse.org\/535655\">535655<\/a> Validate branch names on branch creation<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/533549\">533549<\/a>&nbsp;Don&#39;t prune symbolic refs when fetch.prune = true<\/li>\r\n\t<li>Use a secure random generator to seed nonce for digest authentication<\/li>\r\n\t<li>Retry stale NFS file handles on .git\/config file (https:\/\/git.eclipse.org\/r\/#\/c\/120973\/)<\/li>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/529463\">529463<\/a>&nbsp;ssh: Kill the external process when we&#39;re done instead of waiting forever<\/li>\r\n\t<li>Allow &#39;@&#39; as last character of ref. Previously @ was allowed e.g. in branch names, but not as the last&nbsp;character.<\/li>\r\n\t<li>Don&#39;t throw an exception if a pre-push hook is ignored.<\/li>\r\n\t<li>LFS: Fix potential NPE in LfsPrePushHook<\/li>\r\n\t<li>FS#runProcess: Fix OutputStream left unclosed after IOException<\/li>\r\n<\/ul>\r\n\r\n<h1>Incompatible Changes<\/h1>\r\n\r\n<ul>\r\n\t<li>Remove deprecated Repository#notifyIndexChanged<br \/>\r\n\tImplementors should now override Repository#notifyIndexChanged(boolean)<\/li>\r\n\t<li>Remove deprecated LfsProtocolServlet#getLargeFileRepository<br \/>\r\n\tUse LfsProtocolServlet##getLargeFileRepository(LfsRequest, String, String) instead.<\/li>\r\n\t<li>Remove deprecated Lfs#Lfs(Path)<br \/>\r\n\tUse Lfs#Lfs(Repository) instead.<\/li>\r\n\t<li>Remove deprecated StreamCopyThread#flush<\/li>\r\n\t<li>Remove deprecated SafeBufferedOutputStream<br \/>\r\n\tUse Java 8 BufferedOutputStream instead.<\/li>\r\n\t<li>Remove deprecated EolCanonicalizingInputStream<br \/>\r\n\tUse AutoLFInputStream instead.<\/li>\r\n\t<li>Remove deprecated FileUtils#relativize(String, String)<br \/>\r\n\tUse the more-clearly-named FileUtils#relativizeNativePath(String, String)&nbsp;instead, or directly call FileUtils#relativizePath(String, String, String, boolean).<\/li>\r\n\t<li>Remove deprecated FileUtil using Java 7 NIO<\/li>\r\n\t<li>Remove deprecated TreeWalk#getEolStreamType<br \/>\r\n\tUse TreeWalk#getEolStreamType(OperationType) instead.<\/li>\r\n\t<li>Remove deprecated FileTreeIterator(WorkingTreeIterator, File, FS)<br \/>\r\n\tUse FileTreeIterator#FileTreeIterator(FileTreeIterator, File, FS) instead.<\/li>\r\n\t<li>Remove deprecated TransportHttp#httpOpen(String, URL)<br \/>\r\n\tUse TransportHttp#httpOpen(String, URL, AcceptEncoding) instead.<\/li>\r\n\t<li>Remove deprecated ResolveMerger#processEntry method<\/li>\r\n\t<li>Remove deprecated Repository#getRef<br \/>\r\n\tUse Repository#exactRef(String) or Repository#findRef(String) instead.<\/li>\r\n\t<li>Remove deprecated BitmapBuilder#add<br \/>\r\n\tUse BitmapBuilder#or or BitmapBuilder#addObject instead.<\/li>\r\n\t<li>Remove deprecated LockFile(File, FS) constructor<br \/>\r\n\tUse org.eclipse.jgit.internal.storage.file.LockFile#LockFile(File) instead.<\/li>\r\n\t<li>Remove deprecated IgnoreNode#isIgnored method<br \/>\r\n\tParameter negateFirstMatch is not honored anymore<\/li>\r\n\t<li>Remove deprecated Statistics, UploadPackLogger, UploadPackLoggerChain<br \/>\r\n\tUse PackStatistics and PostUploadHook and PostUploadHookChain instead.<\/li>\r\n\t<li>Remove&nbsp;UploadPack#getPackStatistics<br \/>\r\n\tUse #getStatistics instead<\/li>\r\n\t<li>Remove UploadPack#getLogger and UploadPack#setLogger<\/li>\r\n\t<li>Remove deprecated StoredObjectRepresentationnotAvailableException ctor<br \/>\r\n\tUse #StoredObjectRepresentationNotAvailableException(ObjectToPack, Throwable) instead.<\/li>\r\n\t<li>Remove deprecated ArchiveCommand#putEntry method<br \/>\r\n\tUse #putEntry(Closeable, ObjectId, String, FileMode, ObjectLoader)} instead.<\/li>\r\n\t<li>Fix misspelled class name: EmtpyCommitException -&gt; EmptyCommitException<\/li>\r\n\t<li>RemoteAddCommand#setName(String) and #setUri(URIish): return RemoteAddCommand to allow chaining.<\/li>\r\n<\/ul>\r\n\r\n<h1>Build and Release Engineering<\/h1>\r\n\r\n<ul>\r\n\t<li>Update to latest Photon Orbit R20180606145124<\/li>\r\n\t<li>Update maven plugins to fix Zip Slip vulnerability<\/li>\r\n\t<li>Bazel: Add a target to build jgit commandline tool<\/li>\r\n\t<li>Use eclipse compiler in Maven build. Define profiles &quot;ecj&quot; for using Eclipse compiler and &quot;javac&quot; for using javac including errorprone. By default ecj will be used.<\/li>\r\n\t<li>Upgrade error_prone_core to 2.3.1<\/li>\r\n\t<li>Update SUA to current version.<\/li>\r\n<\/ul>\r\n\r\n<h1>&nbsp;<\/h1>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-06-06 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"5.0.0"}],"state":[{"value":"success"}],"title":"5.0.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/5.0.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.0.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-06-22 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Bug Fixes<\/p>\n<ul><li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536150\">536150<\/a> Release 5.0.0.201806131550-r is missing the org.eclipse.jgit-parent on Maven Central <\/li>\n<li>Respect \"unshallow\" lines in protocol v2<\/li>\n<li>Fix maven site generation failing with javadoc errors<\/li>\n<\/ul><p>Build and Release Engineering<\/p>\n<ul><li>Add project-info reports to maven site<\/li>\n<\/ul>","summary":"","value":"<h1>Bug Fixes<\/h1>\r\n\r\n<ul>\r\n\t<li><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=536150\">536150<\/a>&nbsp;Release 5.0.0.201806131550-r is missing the org.eclipse.jgit-parent on Maven Central&nbsp;<\/li>\r\n\t<li>Respect &quot;unshallow&quot; lines in protocol v2<\/li>\r\n\t<li>Fix maven site generation failing with javadoc errors<\/li>\r\n<\/ul>\r\n\r\n<h1>Build and Release Engineering<\/h1>\r\n\r\n<ul>\r\n\t<li>Add project-info reports to maven site<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.0.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/5.0.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-03-08 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>Features<\/h2>\n<ul><li>LFS: Enable LFS support for the CLI, better error handling<\/li>\n<li>LFS: support merge\/rebase\/cherry-pick\/diff\/compare with LFS files<\/li>\n<li>LFS: Dramatically improve checkout speed with SSH authentication<\/li>\n<li>LFS: pre-push upload support<\/li>\n<li>LFS: Add remote download to SmudgeFilter<\/li>\n<li>Add ObjectIdSerializer<\/li>\n<li>dfs: Try to avoid searching UNREACHABLE_GARBAGE during packing<\/li>\n<li>RepoCommand: generate relative submodule URLs from absolute URLs.<\/li>\n<li>RepoCommand: don't record new commit if tree did not change<\/li>\n<li>RepoCommand: persist unreadable submodules in .gitmodules<\/li>\n<li>Add negotiation statistics to PackStatistics<\/li>\n<li>Basic submodule merge handling (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=494551\">bug 494551<\/a>)<\/li>\n<li>Add class to access WindowCache statistics<\/li>\n<li>Progress reporting for checkout<\/li>\n<\/ul><h2>Performance Improvements<\/h2>\n<ul><li>Add a minimum negotiation feature for fetch. Limits how many \"have\" lines the client sends. This feature is gated behind a \"fetch.useminimalnegotiation\" configuration flag, which defaults to false.<\/li>\n<li>GC: Replace Files methods with File alternatives<\/li>\n<\/ul><h2>Fixes<\/h2>\n<ul><li>Fix DiffFormatter for diffs against working tree with autocrlf=true (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=530106\">bug 530106<\/a>)<\/li>\n<li>Fix processing of gitignore negations (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=409664\">bug 409664<\/a>)<\/li>\n<li>PathMatcher: fix handling of **\/<\/li>\n<li>Don't subclass ThreadLocal to avoid memory leak in NLS (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=449321\">bug 449321<\/a>)<\/li>\n<li>Set context classloader to null in WorkQueue (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=517107\">bug 517107<\/a>)<\/li>\n<li>Fix ssh host name handling for Jsch (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531118\">bug 531118<\/a>)<\/li>\n<li>Fix that Jsch overrides the port in the URI with the one in ~\/.ssh\/config<\/li>\n<li>InitCommand: Don't leave Repository open after Git is closed<\/li>\n<li>MergedReftable to skip shadowed refs in same reftable<\/li>\n<li>Fix CleanCommand not to throw FileNotFoundExceptions (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=514434\">bug 514434<\/a>)<\/li>\n<li>GC: Remove empty references folders<\/li>\n<li>Close RevWalk in BranchTrackingStatus.of() (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=530757\">bug 530757<\/a>)<\/li>\n<li>Fix index blob for merges with CRLF translations (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=499615\">bug 499615<\/a>)<\/li>\n<li>Honor CRLF settings when writing merge results (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=499615\">bug 499615<\/a>)<\/li>\n<li>Minor improvements in git config file inclusions<\/li>\n<li>Enforce DFS blockLimit is a multiple of blockSize<\/li>\n<li>Skip broken symbolic ref in DfsReftableDatabase<\/li>\n<li>Revert handling of ssh IdentityFile to pre-4.9 behavior (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529173\">bug 529173<\/a>)<\/li>\n<li>RefDirectory#hasLooseRef: Fix stream resource leak reported by error-prone<\/li>\n<li>Ensure DirectoryStream is closed promptly<\/li>\n<li>Fix file handle leak in FetchCommand#fetchSubmodules (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526494\">bug 526494<\/a>)<\/li>\n<li>Skip unborn branches in UploadPack<\/li>\n<li>TransportLocal should reuse FS from source repo<\/li>\n<\/ul><h2>Build and Release Engineering<\/h2>\n<ul><li>Upgrade spotbugs-maven-plugin to 3.1.2<\/li>\n<li>Update orbit to S20180302171354 (photon) and R20180206163158 (oxygen)<\/li>\n<li>Update tycho to 1.1.0<\/li>\n<li>Bazel: Support building with Java 9<\/li>\n<li>Update tycho to 1.1.0<\/li>\n<li>Upgrade gson to version 2.8.2<\/li>\n<li>Upgrade commons-compress to 1.15<\/li>\n<li>Upgrade error_prone_core to 2.2.0<\/li>\n<li>Upgrade Spotbugs to 3.1.1<\/li>\n<li>Add com.jcraft.jzlib 1.1.1 (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529129\">bug 529129<\/a>)<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>Features<\/h2>\r\n\r\n<ul>\r\n\t<li>LFS: Enable LFS support for the CLI, better error handling<\/li>\r\n\t<li>LFS: support merge\/rebase\/cherry-pick\/diff\/compare with LFS files<\/li>\r\n\t<li>LFS: Dramatically improve checkout speed with SSH authentication<\/li>\r\n\t<li>LFS: pre-push upload support<\/li>\r\n\t<li>LFS: Add remote download to SmudgeFilter<\/li>\r\n\t<li>Add ObjectIdSerializer<\/li>\r\n\t<li>dfs: Try to avoid searching UNREACHABLE_GARBAGE during packing<\/li>\r\n\t<li>RepoCommand: generate relative submodule URLs from absolute URLs.<\/li>\r\n\t<li>RepoCommand: don&#39;t record new commit if tree did not change<\/li>\r\n\t<li>RepoCommand: persist unreadable submodules in .gitmodules<\/li>\r\n\t<li>Add negotiation statistics to PackStatistics<\/li>\r\n\t<li>Basic submodule merge handling (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=494551\">bug 494551<\/a>)<\/li>\r\n\t<li>Add class to access WindowCache statistics<\/li>\r\n\t<li>Progress reporting for checkout<\/li>\r\n<\/ul>\r\n\r\n<h2>Performance Improvements<\/h2>\r\n\r\n<ul>\r\n\t<li>Add a minimum negotiation feature for fetch. Limits how many &quot;have&quot; lines the client&nbsp;sends. This feature is gated behind a &quot;fetch.useminimalnegotiation&quot; configuration flag, which defaults to false.<\/li>\r\n\t<li>GC: Replace Files methods with File alternatives<\/li>\r\n<\/ul>\r\n\r\n<h2>Fixes<\/h2>\r\n\r\n<ul>\r\n\t<li>Fix DiffFormatter for diffs against working tree with autocrlf=true (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=530106\">bug 530106<\/a>)<\/li>\r\n\t<li>Fix processing of gitignore negations (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=409664\">bug 409664<\/a>)<\/li>\r\n\t<li>PathMatcher: fix handling of **\/<\/li>\r\n\t<li>Don&#39;t subclass ThreadLocal to avoid memory leak in NLS (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=449321\">bug 449321<\/a>)<\/li>\r\n\t<li>Set context classloader to null in WorkQueue (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=517107\">bug 517107<\/a>)<\/li>\r\n\t<li>Fix ssh host name handling for Jsch (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=531118\">bug 531118<\/a>)<\/li>\r\n\t<li>Fix that Jsch overrides the port in the URI with the one in ~\/.ssh\/config<\/li>\r\n\t<li>InitCommand: Don&#39;t leave Repository open after Git is closed<\/li>\r\n\t<li>MergedReftable to skip shadowed refs in same reftable<\/li>\r\n\t<li>Fix CleanCommand not to throw FileNotFoundExceptions (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=514434\">bug 514434<\/a>)<\/li>\r\n\t<li>GC: Remove empty references folders<\/li>\r\n\t<li>Close RevWalk in BranchTrackingStatus.of() (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=530757\">bug 530757<\/a>)<\/li>\r\n\t<li>Fix index blob for merges with CRLF translations (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=499615\">bug 499615<\/a>)<\/li>\r\n\t<li>Honor CRLF settings when writing merge results (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=499615\">bug 499615<\/a>)<\/li>\r\n\t<li>Minor improvements in git config file inclusions<\/li>\r\n\t<li>Enforce DFS blockLimit is a multiple of blockSize<\/li>\r\n\t<li>Skip broken symbolic ref in DfsReftableDatabase<\/li>\r\n\t<li>Revert handling of ssh IdentityFile to pre-4.9 behavior (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529173\">bug 529173<\/a>)<\/li>\r\n\t<li>RefDirectory#hasLooseRef: Fix stream resource leak reported by error-prone<\/li>\r\n\t<li>Ensure DirectoryStream is closed promptly<\/li>\r\n\t<li>Fix file handle leak in FetchCommand#fetchSubmodules (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526494\">bug 526494<\/a>)<\/li>\r\n\t<li>Skip unborn branches in UploadPack<\/li>\r\n\t<li>TransportLocal should reuse FS from source repo<\/li>\r\n<\/ul>\r\n\r\n<h2>Build and Release Engineering<\/h2>\r\n\r\n<ul>\r\n\t<li>Upgrade spotbugs-maven-plugin to 3.1.2<\/li>\r\n\t<li>Update orbit to S20180302171354 (photon) and R20180206163158 (oxygen)<\/li>\r\n\t<li>Update tycho to 1.1.0<\/li>\r\n\t<li>Bazel: Support building with Java 9<\/li>\r\n\t<li>Update tycho to 1.1.0<\/li>\r\n\t<li>Upgrade gson to version 2.8.2<\/li>\r\n\t<li>Upgrade commons-compress to 1.15<\/li>\r\n\t<li>Upgrade error_prone_core to 2.2.0<\/li>\r\n\t<li>Upgrade Spotbugs to 3.1.1<\/li>\r\n\t<li>Add com.jcraft.jzlib 1.1.1 (<a href=\"http:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=529129\">bug 529129<\/a>)<\/li>\r\n<\/ul>\r\n\r\n<div>&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-02-21 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.11.0"}],"state":[{"value":"success"}],"title":"4.11.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.11.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.11.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.11.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-12-30 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\t\tFeatures<\/h2>\n<ul><li>\n<p>\t\t\t\tCloneCommand: option to set FS to be used\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tInitCommand: option to set FS to be used\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tAdd a command to deinitialize submodules\n\t\t<\/p><\/li>\n<li>\n\t\t\tFileBasedConfig: support for relative includes<\/li>\n<li>\n\t\t\tObjectDirectory: Add pack directory getter<\/li>\n<li>\n\t\t\tAdd a setting for fsck to check connectivity only<\/li>\n<li>\n\t\t\tdfs: reftable backed DfsRefDatabase: DfsReftableDatabase is a new alternative for DfsRefDatabase that handles more operations for the implementor by delegating through reftables.<\/li>\n<li>\n\t\t\tSupport symbolic references in ReceiveCommand<\/li>\n<\/ul><h2>\n\t\tPerformance improvements<\/h2>\n<ul><li>\n\t\t\tDfsBlockCache.hasBlock0: quickly check for file in cache<\/li>\n<li>\n\t\t\tPerformance improvement on writing a large index<\/li>\n<li>\n\t\t\tBitmapWalker: do not revisit objects in bitmap<\/li>\n<li>\n\t\t\tIntroduce RawText#load.<\/li>\n<li>\n\t\t\tSkip unreachable garbage packs in dfs fsck<\/li>\n<\/ul><h2>\n\t\tBug Fixes<\/h2>\n<ul><li>\n<p>\t\t\t\tWorkingTreeIterator should pass FS to submodules\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tUse submodule name instead of path as key in config\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tURIish: support for empty ports (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=519187\">bug 519187<\/a>)\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tStrings#convertGlob: fix escaping of patterns like [\\[] (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528886\">bug 528886<\/a>)\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tConfig: Drop backslash in invalid escape sequences in subsections\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tConfig: Match C git behavior more closely in escaping values\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tConfig: Rewrite subsection and value escaping and parsing\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tFix javadoc errors raised by doclint\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tDfsFsck: Skip unborn branches and symrefs to nowhere\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tMake Config.readIncludedConfig a noop by default\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tRemove use of deprecated X509HostnameVerifier\n\t\t<\/p><\/li>\n<li>\n\t\t\tTransportHttp: retry on IOException with another mechanism when a 401 occurs on POST and the server advertises Negotiate (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=501167\">bug 501167<\/a>)<\/li>\n<li>\n\t\t\tReject pack if delta exceeds array size limit<\/li>\n<li>\n\t\t\tAvoid loading and merging binary data in ResolveMerger<\/li>\n<li>\n\t\t\tAvoid bad rounding \"1 year, 12 months\" in date formatter (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=525907\">bug 525907<\/a>)<\/li>\n<\/ul><h2>\n\t\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\t\tUpgrade error_prone_core to 2.1.3<\/li>\n<li>\n\t\t\tUpdate Jetty to 9.4.8.v20171121<\/li>\n<li>\n\t\t\tAdd header Automatic-Module-Name for Java 9 (bug 529075)<\/li>\n<li>\n\t\t\tUpdpate oxygen orbit to R20170919201930 and remove old orbit repos<\/li>\n<li>\n\t\t\tUpdate Apache httpclient to 4.5.2 and httpcore to 4.4.6<\/li>\n<li>\n\t\t\tSpecify consistent version range for junit in OSGi manifests<\/li>\n<li>\n<p>\t\t\t\tRemove maven profile jgit.java8\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tReenable failing the build on javadoc errors\n\t\t<\/p><\/li>\n<li>\n\t\t\tRequire maven 3.5.2<\/li>\n<li>\n\t\t\tUpgrade spotbugs-maven-plugin to 3.1.0-RC8<\/li>\n<li>\n\t\t\tUpgrade maven-compiler-plugin to 3.7.0<\/li>\n<li>\n\t\t\tUpdate japicmp-maven-plugin to 0.11.0<\/li>\n<li>\n\t\t\tUpgrade spotbugs-maven-plugin to 3.1.0<\/li>\n<li>\n<p>\t\t\t\tUpgrade maven-javadoc-plugin to 3.0.0\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tUpgrade maven-surefire{-report}-plugin to 2.20.1\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tUpgrade maven-dependency-plugin to 3.0.2\n\t\t<\/p><\/li>\n<li>\n<p>\t\t\t\tUpgrade maven-shade-plugin to 3.1.0\n\t\t<\/p><\/li>\n<\/ul><p>\t\t <\/p>\n<p> <\/p>\n","summary":"","value":"<div>\r\n\t<h2>\r\n\t\tFeatures<\/h2>\r\n\t<ul>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tCloneCommand: option to set FS to be used<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tInitCommand: option to set FS to be used<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tAdd a command to deinitialize submodules<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\tFileBasedConfig: support for relative includes<\/li>\r\n\t\t<li>\r\n\t\t\tObjectDirectory: Add pack directory getter<\/li>\r\n\t\t<li>\r\n\t\t\tAdd a setting for fsck to check connectivity only<\/li>\r\n\t\t<li>\r\n\t\t\tdfs: reftable backed DfsRefDatabase: DfsReftableDatabase is a new alternative for DfsRefDatabase that handles more operations for the implementor by delegating through reftables.<\/li>\r\n\t\t<li>\r\n\t\t\tSupport symbolic references in ReceiveCommand<\/li>\r\n\t<\/ul>\r\n\t<h2>\r\n\t\tPerformance improvements<\/h2>\r\n\t<ul>\r\n\t\t<li>\r\n\t\t\tDfsBlockCache.hasBlock0: quickly check for file in cache<\/li>\r\n\t\t<li>\r\n\t\t\tPerformance improvement on writing a large index<\/li>\r\n\t\t<li>\r\n\t\t\tBitmapWalker: do not revisit objects in bitmap<\/li>\r\n\t\t<li>\r\n\t\t\tIntroduce RawText#load.<\/li>\r\n\t\t<li>\r\n\t\t\tSkip unreachable garbage packs in dfs fsck<\/li>\r\n\t<\/ul>\r\n\t<h2>\r\n\t\tBug Fixes<\/h2>\r\n\t<ul>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tWorkingTreeIterator should pass FS to submodules<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tUse submodule name instead of path as key in config<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tURIish: support for empty ports (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=519187\">bug 519187<\/a>)<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tStrings#convertGlob: fix escaping of patterns like [\\[] (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528886\">bug 528886<\/a>)<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tConfig: Drop backslash in invalid escape sequences in subsections<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tConfig: Match C git behavior more closely in escaping values<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tConfig: Rewrite subsection and value escaping and parsing<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tFix javadoc errors raised by doclint<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tDfsFsck: Skip unborn branches and symrefs to nowhere<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tMake Config.readIncludedConfig a noop by default<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tRemove use of deprecated X509HostnameVerifier<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\tTransportHttp: retry on IOException with another mechanism when a 401 occurs on POST and the server advertises Negotiate (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=501167\">bug 501167<\/a>)<\/li>\r\n\t\t<li>\r\n\t\t\tReject pack if delta exceeds array size limit<\/li>\r\n\t\t<li>\r\n\t\t\tAvoid loading and merging binary data in ResolveMerger<\/li>\r\n\t\t<li>\r\n\t\t\tAvoid bad rounding &quot;1 year, 12 months&quot; in date formatter (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=525907\">bug 525907<\/a>)<\/li>\r\n\t<\/ul>\r\n\t<h2>\r\n\t\tBuild and Release Engineering<\/h2>\r\n\t<ul>\r\n\t\t<li>\r\n\t\t\tUpgrade error_prone_core to 2.1.3<\/li>\r\n\t\t<li>\r\n\t\t\tUpdate Jetty to 9.4.8.v20171121<\/li>\r\n\t\t<li>\r\n\t\t\tAdd header Automatic-Module-Name for Java 9 (bug 529075)<\/li>\r\n\t\t<li>\r\n\t\t\tUpdpate oxygen orbit to R20170919201930 and remove old orbit repos<\/li>\r\n\t\t<li>\r\n\t\t\tUpdate Apache httpclient to 4.5.2 and httpcore to 4.4.6<\/li>\r\n\t\t<li>\r\n\t\t\tSpecify consistent version range for junit in OSGi manifests<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tRemove maven profile jgit.java8<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tReenable failing the build on javadoc errors<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\tRequire maven 3.5.2<\/li>\r\n\t\t<li>\r\n\t\t\tUpgrade spotbugs-maven-plugin to 3.1.0-RC8<\/li>\r\n\t\t<li>\r\n\t\t\tUpgrade maven-compiler-plugin to 3.7.0<\/li>\r\n\t\t<li>\r\n\t\t\tUpdate japicmp-maven-plugin to 0.11.0<\/li>\r\n\t\t<li>\r\n\t\t\tUpgrade spotbugs-maven-plugin to 3.1.0<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tUpgrade maven-javadoc-plugin to 3.0.0<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tUpgrade maven-surefire{-report}-plugin to 2.20.1<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tUpgrade maven-dependency-plugin to 3.0.2<\/div>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t\t<div>\r\n\t\t\t\tUpgrade maven-shade-plugin to 3.1.0<\/div>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-12-20 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.10.0"}],"state":[{"value":"success"}],"title":"4.10.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.10.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.10.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.10.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-12-15 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following issues:<\/p>\n<ul><li>\n\t\tWrite packed-refs directly when cloning (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528497\">bug 528497<\/a>)<\/li>\n<li>\n\t\tConfig: Remove the include functionality (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528781\">bug 528781<\/a>)<\/li>\n<li>\n\t\tFix IllegalThreadStateException if stderr closed without exiting (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528335\">bug 528335<\/a>)<\/li>\n<li>\n\t\tLfsServerText: Fix formatting of invalidPathInfo message<\/li>\n<li>\n\t\tInvalidLongObjectIdException: Fix formatting of message<\/li>\n<li>\n\t\tFileLfsServlet: Do not pretty print json response<\/li>\n<\/ul><p>\t <\/p>\n","summary":"","value":"<p>This release fixes the following issues:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tWrite packed-refs directly when cloning (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528497\">bug 528497<\/a>)<\/li>\r\n\t<li>\r\n\t\tConfig: Remove the include functionality (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528781\">bug 528781<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix IllegalThreadStateException if stderr closed without exiting (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=528335\">bug 528335<\/a>)<\/li>\r\n\t<li>\r\n\t\tLfsServerText: Fix formatting of invalidPathInfo message<\/li>\r\n\t<li>\r\n\t\tInvalidLongObjectIdException: Fix formatting of message<\/li>\r\n\t<li>\r\n\t\tFileLfsServlet: Do not pretty print json response<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-12-03 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following issues<\/p>\n<ul><li>\n\t\tWork-around for a Jsch bug which causes timeouts configured in ~\/.ssh\/config are interpreted in milliseconds instead of seconds. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526867\">bug 526867<\/a>)<\/li>\n<li>\n\t\tWork around for a Jsch bug: ensure the user name is set from URI (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526778\">bug 526778<\/a>)<\/li>\n<li>\n\t\tEnsure that ~ in ssh config is replaced before Jsch sees it (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526175\">bug 526175<\/a>)<\/li>\n<li>\n\t\tFix NPE in TransportGitSsh.ExtSession.exec() (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=527383\">bug 527383<\/a>)<\/li>\n<li>\n\t\tAdd missing help text for rev-parse's --verify option<\/li>\n<li>\n\t\tRemove final modifier on args4j argument field in RevParse<\/li>\n<li>\n\t\tPerformance improvement in FileRepository: add pack-based inserter implementation<\/li>\n<li>\n\t\tObjectDirectory: Remove last modified check in insertPack so that insertPack does not insert a duplicate entry.<\/li>\n<li>\n\t\tReintroduce protected method which removal broke EMF Compare, see abf420302 for details.<\/li>\n<li>\n\t\tAvoid bad rounding \"1 year, 12 months\" in date formatter<\/li>\n<li>\n\t\tGC: Remove stale temporary packs and indexes at the end of the GC process so they do not accumulate. To avoid interfering with a possible concurrent JGit GC process in the same repository, only delete temporary files that are older than one day.<\/li>\n<li>\n\t\tFix LockFile semantics when running on NFS. When running on NFS there was a chance that JGits LockFile semantic is broken because File#createNewFile() may allow multiple clients to create the same lock file in parallel. If the new config option core.supportsAtomicCreateNewFile is true then File#createNewFile() is trusted and the behaviour doesn't change. If core.supportsAtomicCreateNewFile is set to false then after successful creation of the lock file use the workaround described in [1] to avoid the problem.<br \/>\n\t\t[1] https:\/\/www.time-travellers.org\/shane\/papers\/NFS_considered_harmful.html, section III.d) \"Exclusive File Creation<\/li>\n<li>\n\t\tHonor trustFolderStats also when reading packed-refs. Then the list of packed refs was cached in RefDirectory based on mtime of the packed-refs file. This may fail on NFS when file attributes are cached. A cached mtime of the packed-refs file could cause JGit to trust the cached content of this file and to overlook that the file is modified. Honor the config option trustFolderStats and always read the packed-refs content if the option is false. By default this option is set to true and this fix is not active.<\/li>\n<\/ul>","summary":"","value":"<p>This release fixes the following issues<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tWork-around for a Jsch bug which causes timeouts configured in ~\/.ssh\/config are interpreted in milliseconds instead of seconds. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526867\">bug 526867<\/a>)<\/li>\r\n\t<li>\r\n\t\tWork around for a Jsch bug: ensure the user name is set from URI (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526778\">bug 526778<\/a>)<\/li>\r\n\t<li>\r\n\t\tEnsure that ~ in ssh config is replaced before Jsch sees it (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=526175\">bug 526175<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix NPE in TransportGitSsh.ExtSession.exec() (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=527383\">bug 527383<\/a>)<\/li>\r\n\t<li>\r\n\t\tAdd missing help text for rev-parse&#39;s --verify option<\/li>\r\n\t<li>\r\n\t\tRemove final modifier on args4j argument field in RevParse<\/li>\r\n\t<li>\r\n\t\tPerformance improvement in FileRepository: add pack-based inserter implementation<\/li>\r\n\t<li>\r\n\t\tObjectDirectory: Remove last modified check in insertPack so that insertPack does not insert a duplicate entry.<\/li>\r\n\t<li>\r\n\t\tReintroduce protected method which removal broke EMF Compare, see abf420302 for details.<\/li>\r\n\t<li>\r\n\t\tAvoid bad rounding &quot;1 year, 12 months&quot; in date formatter<\/li>\r\n\t<li>\r\n\t\tGC: Remove stale temporary packs and indexes at the end of the GC process so they do not accumulate. To avoid interfering with a possible concurrent JGit GC process in the same repository, only delete temporary files that are older than one day.<\/li>\r\n\t<li>\r\n\t\tFix LockFile semantics when running on NFS.&nbsp;When running on NFS there was a chance that JGits LockFile semantic is broken because File#createNewFile() may allow multiple clients to create the same lock file in parallel. If the new config option core.supportsAtomicCreateNewFile is true then File#createNewFile() is trusted and the behaviour doesn&#39;t change. If core.supportsAtomicCreateNewFile is set to false then after successful creation of the lock file use the workaround described in [1] to avoid the problem.<br \/>\r\n\t\t[1] https:\/\/www.time-travellers.org\/shane\/papers\/NFS_considered_harmful.html, section III.d) &quot;Exclusive File Creation<\/li>\r\n\t<li>\r\n\t\tHonor trustFolderStats also when reading packed-refs.&nbsp;Then the list of packed refs was cached in RefDirectory based on mtime of the packed-refs file. This may fail on NFS when file attributes are cached. A cached mtime of the packed-refs file could cause JGit to trust the cached content of this file and to overlook that the file is modified. Honor the config option trustFolderStats and always read the packed-refs content if the option is false. By default this option is set to true and this fix is not active.<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-11-22 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This releases provides workarounds for problems which may occur when running multiple JGit processes on different machines against repositories residing on the same shared NFS filesystem.<\/p>\n<p>\t <\/p>\n<p>\t<strong>Fix LockFile semantics when running on NFS<\/strong><\/p>\n<p>\t <\/p>\n<p>\tWhen running on NFS there was a chance that JGits LockFile semantic is broken because File#createNewFile() may allow multiple clients to create the same lock file in parallel. If the new config option core.supportsAtomicCreateNewFile is true then File#createNewFile() is trusted and the behaviour doesn't change. If core.supportsAtomicCreateNewFile is set to false then after successful creation of the lock file use the workaround described in [1] to avoid the problem.<\/p>\n<p>\t <\/p>\n<p>\t[1] https:\/\/www.time-travellers.org\/shane\/papers\/NFS_considered_harmful.html, section III.d) \"Exclusive File Creation\"<\/p>\n<p> <\/p>\n<p><strong>Honor trustFolderStats also when reading packed-refs<\/strong><\/p>\n<p>Then the list of packed refs was cached in RefDirectory based on mtime of the packed-refs file. This may fail on NFS when file attributes are cached. A cached mtime of the packed-refs file could cause JGit to trust the cached content of this file and to overlook that the file is modified. Honor the config option trustFolderStats and always read the packed-refs content if the option is false. By default this option is set to true and this fix is not active.<\/p>\n","summary":"","value":"<div>\r\n\tThis releases provides workarounds for problems which may occur when running multiple JGit processes on different machines against repositories residing on the same shared NFS filesystem.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\t<strong>Fix LockFile semantics when running on NFS<\/strong><\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tWhen running on NFS there was a chance that JGits LockFile semantic is broken because File#createNewFile() may allow multiple clients to create the same lock file in parallel. If the new config option core.supportsAtomicCreateNewFile is true then File#createNewFile() is trusted and the behaviour doesn&#39;t change. If core.supportsAtomicCreateNewFile is set to false then after successful creation of the lock file use the workaround described in [1] to avoid the problem.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\t[1] https:\/\/www.time-travellers.org\/shane\/papers\/NFS_considered_harmful.html, section III.d) &quot;Exclusive File Creation&quot;<\/div>\r\n<p>&nbsp;<\/p>\r\n<p><strong>Honor trustFolderStats also when reading packed-refs<\/strong><\/p>\r\n<p>Then the list of packed refs was cached in RefDirectory based on mtime of the packed-refs file. This may fail on NFS when file attributes are cached. A cached mtime of the packed-refs file could cause JGit to trust the cached content of this file and to overlook that the file is modified. Honor the config option trustFolderStats and always read the packed-refs content if the option is false. By default this option is set to true and this fix is not active.<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.4","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.4","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-10-04 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tImplement atomic BatchRefUpdates for RefDirectory. The existing packed-refs file provides a mechanism for implementing atomic multi-ref updates without any changes to the on-disk format or lockfile protocol. We just need to make sure that there are no loose refs involved in the transaction, which we can achieve by packing the refs while holding locks on all loose refs. Full details of the algorithm are in the PackedBatchRefUpdate javadoc.<\/li>\n<li>\n\t\tReftable: implement a new ref storage format. Some repositories contain a lot of references (e.g. android at 866k, rails at 31k). The reftable format provides:\n<ul><li>\n\t\t\t\tNear constant time lookup for any single reference, even when the repository is cold and not in process or kernel cache.<\/li>\n<li>\n\t\t\t\tNear constant time verification a SHA-1 is referred to by at least one reference (for allow-tip-sha1-in-want).<\/li>\n<li>\n\t\t\t\tEfficient lookup of an entire namespace, such as `refs\/tags\/`.<\/li>\n<li>\n\t\t\t\tSupport atomic push `O(size_of_update)` operations.<\/li>\n<li>\n\t\t\t\tCombine reflog storage with ref storage.<\/li>\n<\/ul><\/li>\n<li>\n\t\tFetch submodule repo before resolving commits (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=470318\">bug 470318<\/a>)<\/li>\n<li>\n\t\tHandle SSL handshake failures in TransportHttp, use CredentialsProvider to inform the user (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=374703\">bug 374703<\/a>)<\/li>\n<li>\n\t\tSupport http.&lt;url&gt;.* configs<\/li>\n<li>\n\t\tAdd BlobObjectChecker<\/li>\n<li>\n\t\tImprove getting typed values from a Config to enable handling invalid configuration options (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520978\">bug 520978<\/a>)<\/li>\n<li>\n\t\tSupport most %-token substitutions in OpenSshConfig (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=496170\">bug 496170<\/a>)<\/li>\n<li>\n\t\tLet Jsch know about ~\/.ssh\/config. Ensure the Jsch instance used knows about ~\/.ssh\/config. This enables Jsch to honor more user configurations, in particular also the UserKnownHostsFile configuration, or additional identities given via multiple IdentityFile entries. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=490939\">bug 490939<\/a>)<\/li>\n<li>\n\t\tAdd support to follow HTTP redirects (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=465167\">bug 465167<\/a>)\n<ul><li>\n\t\t\t\tImplement config setting http.followRedirects<\/li>\n<li>\n\t\t\t\tNumber of redirects followed can be limited by http.maxRedirects (default 5)<\/li>\n<\/ul><\/li>\n<li>\n\t\tSend a detailed event on working tree modifications to provide the foundations for better file change tracking (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=500106\">bug 500106<\/a>)<\/li>\n<li>\n\t\tAdd dfs fsck implementation<\/li>\n<li>\n\t\tSupport -merge attribute in binary macro. The merger is now able to react to the use of the merge attribute. The value unset and the custom value 'binary' are handled (-merge and merge=binary) (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=517128\">bug 517128<\/a>)<\/li>\n<li>\n\t\tSupport --match functionality in DescribeCommand (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=518377\">bug 518377<\/a>)<\/li>\n<li>\n\t\tAllow to programmatically set FastForwardMode for PullCommand (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=517847\">bug 517847<\/a>)<\/li>\n<li>\n\t\tAdd support for config option \"pull.ff\" (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=474174\">bug 474174<\/a>)<\/li>\n<li>\n\t\tAdd a new singlePack option to PackConfig. If set, \"singlePack\" will create a single GC pack file for all objects reachable from refs\/*. If not set, the GC pack will contain object reachable from refs\/heads\/* and refs\/tags\/*, and the GC_REST pack will contain all other reachable objects.<\/li>\n<li>\n\t\tfetch: Accept any SHA-1 on left hand side of refspec<\/li>\n<\/ul><h2>\n\tJGit Command Line<\/h2>\n<ul><li>\n\t\tAdded API to TextBuiltin for piped usage.<\/li>\n<li>\n\t\tAdd --match option for `jgit describe` to CLI (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=518377\">bug 518377<\/a>)<\/li>\n<\/ul><h2>\n\tPerformance Improvements<\/h2>\n<ul><li>\n\t\tReceivePack: clear advertised .haves if application changes refs to avoid over-advertising \".have\" lines<\/li>\n<li>\n\t\tReftable: see above<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tUpgrade Maven compiler plugins<\/li>\n<li>\n\t\tAdd org.apache.commons.codec 1.9.0 to target platform<\/li>\n<li>\n\t\tUpdate args4j to 2.33 (CQ: 11068)<\/li>\n<li>\n\t\tUpdate Oxygen Orbit p2 repository to R20170516192513<\/li>\n<li>\n\t\tReplace findbugs by spotbugs<\/li>\n<\/ul><h2>\n\tBug Fixes<\/h2>\n<ul><li>\n\t\tFix missing RefsChangedEvent when packed refs are used (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=521296\">bug 521296<\/a>)<\/li>\n<li>\n\t\tFix Daemon.stop() to actually stop the listener thread (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=376369\">bug 376369<\/a>)<\/li>\n<li>\n\t\tRemove workaround for bug in Java's ReferenceQueue which was fixed in Java 8. '''Minimum Java version 8-b100:''' JGit 4.9 removes a  <a href=\"https:\/\/git.eclipse.org\/r\/#\/c\/104245\/\">workaround<\/a> for a <a href=\"http:\/\/bugs.sun.com\/bugdatabase\/view_bug.do?bug_id=6837858\">bug<\/a> in ReferenceQueue of Sun's Java 5, 6, 7 implementation. This bug was fixed in <a href=\"http:\/\/hg.openjdk.java.net\/jdk8\/jdk8\/jdk\/rev\/858c75eb83b5\">JDK 8-b100<\/a> hence this is the minimum supported Java version for JGit 4.9.<\/li>\n<li>\n\t\tDon't assume name = path in .gitmodules (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=508801\">bug 508801<\/a>)<\/li>\n<li>\n\t\tFetchCommand: pass on CredentialsProvider to submodule fetches (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=515325\">bug 515325<\/a>)<\/li>\n<li>\n\t\tExclude file matching: fix backtracking on match failures after \"**\" (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520920\">bug 520920<\/a>)<\/li>\n<li>\n\t\tFix path pattern matching to work also for gitattributes (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=508568\">bug 508568<\/a>)<\/li>\n<li>\n\t\tIgnore invalid TagOpt values (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=429625\">bug 429625<\/a>)<\/li>\n<li>\n\t\tFix default directory used to clone when setDirectory wasn't called (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=519883\">bug 519883<\/a>)<\/li>\n<li>\n\t\tDo authentication re-tries on HTTP POST (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=513043\">bug 513043<\/a>)<\/li>\n<li>\n\t\tFix exception handling for opening bitmap index files<\/li>\n<li>\n\t\tDo not apply pushInsteadOf to existing pushUris (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=393170\">bug 393170<\/a>)<\/li>\n<li>\n\t\tRecord submodule paths with untracked changes as FileMode.GITLINK (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520702\">bug 520702<\/a>)<\/li>\n<li>\n\t\tEnsure EOL stream type is DIRECT when -text attribute is present. Otherwise fancy combinations of attributes (binary or -text in combination with crlf or eol) may result in the corruption of binary data. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520910\">bug 520910<\/a>)<\/li>\n<li>\n\t\tUse relative paths for attribute rule matching (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520677\">bug 520677<\/a>)<\/li>\n<li>\n\t\tTreat RawText of binary data as file with one single line. This avoids executing mergeAlgorithm.merge on binary data, which is unlikely to be useful.<\/li>\n<li>\n\t\tFix committing empty commits (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=510685\">bug 510685<\/a>)<\/li>\n<li>\n\t\tFix JGit set core.fileMode to false by default instead of true for non Windows OS. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=519887\">bug 519887<\/a>)<\/li>\n<li>\n\t\tFix matching ignores and attributes pattern of form a\/b\/**.<\/li>\n<li>\n\t\tFix deleting symrefs<\/li>\n<li>\n\t\tFix bug in multiple tag handling on DescribeCommand (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=518377\">bug 518377<\/a>)<\/li>\n<li>\n\t\tpushInsteadOf configuration is ignored by EGit. <strong>Note:<\/strong> Up to now JGit mistakenly applied pushInsteadOf also to existing pushUris. If some repositories had relied on this mis-feature, pushes may newly suddenly fail (the uncritical case; the config just needs to be fixed) or even still succeed but push to unexpected places, namely to the non-rewritten pushUrls (the critical case). (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=393170\">bug 393170<\/a>)<\/li>\n<\/ul>","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tImplement atomic BatchRefUpdates for RefDirectory. The existing packed-refs file provides a mechanism for implementing atomic multi-ref updates without any changes to the on-disk format or lockfile protocol. We just need to make sure that there are no loose refs involved in the transaction, which we can achieve by packing the refs while holding locks on all loose refs. Full details of the algorithm are in the PackedBatchRefUpdate javadoc.<\/li>\r\n\t<li>\r\n\t\tReftable: implement a new ref storage format. Some repositories contain a lot of references (e.g. android at 866k, rails at 31k). The reftable format provides:\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tNear constant time lookup for any single reference, even when the repository is cold and not in process or kernel cache.<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tNear constant time verification a SHA-1 is referred to by at least one reference (for allow-tip-sha1-in-want).<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tEfficient lookup of an entire namespace, such as `refs\/tags\/`.<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport atomic push `O(size_of_update)` operations.<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tCombine reflog storage with ref storage.<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tFetch submodule repo before resolving commits (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=470318\">bug 470318<\/a>)<\/li>\r\n\t<li>\r\n\t\tHandle SSL handshake failures in TransportHttp, use CredentialsProvider to inform the user (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=374703\">bug 374703<\/a>)<\/li>\r\n\t<li>\r\n\t\tSupport http.&lt;url&gt;.* configs<\/li>\r\n\t<li>\r\n\t\tAdd BlobObjectChecker<\/li>\r\n\t<li>\r\n\t\tImprove getting typed values from a Config to enable handling invalid configuration options (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520978\">bug 520978<\/a>)<\/li>\r\n\t<li>\r\n\t\tSupport most %-token substitutions in OpenSshConfig (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=496170\">bug 496170<\/a>)<\/li>\r\n\t<li>\r\n\t\tLet Jsch know about ~\/.ssh\/config. Ensure the Jsch instance used knows about ~\/.ssh\/config. This enables Jsch to honor more user configurations, in particular also the UserKnownHostsFile configuration, or additional identities given via multiple IdentityFile entries. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=490939\">bug 490939<\/a>)<\/li>\r\n\t<li>\r\n\t\tAdd support to follow HTTP redirects (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=465167\">bug 465167<\/a>)\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tImplement config setting http.followRedirects<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tNumber of redirects followed can be limited by http.maxRedirects (default 5)<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tSend a detailed event on working tree modifications to provide the foundations for better file change tracking (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=500106\">bug 500106<\/a>)<\/li>\r\n\t<li>\r\n\t\tAdd dfs fsck implementation<\/li>\r\n\t<li>\r\n\t\tSupport -merge attribute in binary macro. The merger is now able to react to the use of the merge attribute. The value unset and the custom value &#39;binary&#39; are handled (-merge and merge=binary) (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=517128\">bug 517128<\/a>)<\/li>\r\n\t<li>\r\n\t\tSupport --match functionality in DescribeCommand (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=518377\">bug 518377<\/a>)<\/li>\r\n\t<li>\r\n\t\tAllow to programmatically set FastForwardMode for PullCommand (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=517847\">bug 517847<\/a>)<\/li>\r\n\t<li>\r\n\t\tAdd support for config option &quot;pull.ff&quot; (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=474174\">bug 474174<\/a>)<\/li>\r\n\t<li>\r\n\t\tAdd a new singlePack option to PackConfig. If set, &quot;singlePack&quot; will create a single GC pack file for all objects reachable from refs\/*. If not set, the GC pack will contain object reachable from refs\/heads\/* and refs\/tags\/*, and the GC_REST pack will contain all other reachable objects.<\/li>\r\n\t<li>\r\n\t\tfetch: Accept any SHA-1 on left hand side of refspec<\/li>\r\n<\/ul>\r\n<h2>\r\n\tJGit Command Line<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdded API to TextBuiltin for piped usage.<\/li>\r\n\t<li>\r\n\t\tAdd --match option for `jgit describe` to CLI (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=518377\">bug 518377<\/a>)<\/li>\r\n<\/ul>\r\n<h2>\r\n\tPerformance Improvements<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tReceivePack: clear advertised .haves if application changes refs to avoid over-advertising &quot;.have&quot; lines<\/li>\r\n\t<li>\r\n\t\tReftable: see above<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpgrade Maven compiler plugins<\/li>\r\n\t<li>\r\n\t\tAdd org.apache.commons.codec 1.9.0 to target platform<\/li>\r\n\t<li>\r\n\t\tUpdate args4j to 2.33 (CQ: 11068)<\/li>\r\n\t<li>\r\n\t\tUpdate Oxygen Orbit p2 repository to R20170516192513<\/li>\r\n\t<li>\r\n\t\tReplace findbugs by spotbugs<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBug Fixes<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tFix missing RefsChangedEvent when packed refs are used (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=521296\">bug 521296<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix Daemon.stop() to actually stop the listener thread (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=376369\">bug 376369<\/a>)<\/li>\r\n\t<li>\r\n\t\tRemove workaround for bug in Java&#39;s ReferenceQueue which was fixed in Java 8. &#39;&#39;&#39;Minimum Java version 8-b100:&#39;&#39;&#39; JGit 4.9 removes a &nbsp;<a href=\"https:\/\/git.eclipse.org\/r\/#\/c\/104245\/\">workaround<\/a> for a <a href=\"http:\/\/bugs.sun.com\/bugdatabase\/view_bug.do?bug_id=6837858\">bug<\/a> in ReferenceQueue of Sun&#39;s Java 5, 6, 7 implementation. This bug was fixed in <a href=\"http:\/\/hg.openjdk.java.net\/jdk8\/jdk8\/jdk\/rev\/858c75eb83b5\">JDK 8-b100<\/a>&nbsp;hence this is the minimum supported Java version for JGit 4.9.<\/li>\r\n\t<li>\r\n\t\tDon&#39;t assume name = path in .gitmodules (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=508801\">bug 508801<\/a>)<\/li>\r\n\t<li>\r\n\t\tFetchCommand: pass on CredentialsProvider to submodule fetches (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=515325\">bug 515325<\/a>)<\/li>\r\n\t<li>\r\n\t\tExclude file matching: fix backtracking on match failures after &quot;**&quot; (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520920\">bug 520920<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix path pattern matching to work also for gitattributes (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=508568\">bug 508568<\/a>)<\/li>\r\n\t<li>\r\n\t\tIgnore invalid TagOpt values (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=429625\">bug 429625<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix default directory used to clone when setDirectory wasn&#39;t called (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=519883\">bug 519883<\/a>)<\/li>\r\n\t<li>\r\n\t\tDo authentication re-tries on HTTP POST (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=513043\">bug 513043<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix exception handling for opening bitmap index files<\/li>\r\n\t<li>\r\n\t\tDo not apply pushInsteadOf to existing pushUris (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=393170\">bug 393170<\/a>)<\/li>\r\n\t<li>\r\n\t\tRecord submodule paths with untracked changes as FileMode.GITLINK (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520702\">bug 520702<\/a>)<\/li>\r\n\t<li>\r\n\t\tEnsure EOL stream type is DIRECT when -text attribute is present. Otherwise fancy combinations of attributes (binary or -text in combination with crlf or eol) may result in the corruption of binary data. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520910\">bug 520910<\/a>)<\/li>\r\n\t<li>\r\n\t\tUse relative paths for attribute rule matching (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=520677\">bug 520677<\/a>)<\/li>\r\n\t<li>\r\n\t\tTreat RawText of binary data as file with one single line. This avoids executing mergeAlgorithm.merge on binary data, which is unlikely to be useful.<\/li>\r\n\t<li>\r\n\t\tFix committing empty commits (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=510685\">bug 510685<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix JGit set core.fileMode to false by default instead of true for non Windows OS. (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=519887\">bug 519887<\/a>)<\/li>\r\n\t<li>\r\n\t\tFix matching ignores and attributes pattern of form a\/b\/**.<\/li>\r\n\t<li>\r\n\t\tFix deleting symrefs<\/li>\r\n\t<li>\r\n\t\tFix bug in multiple tag handling on DescribeCommand (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=518377\">bug 518377<\/a>)<\/li>\r\n\t<li>\r\n\t\tpushInsteadOf configuration is ignored by EGit. <strong>Note:<\/strong> Up to now JGit mistakenly applied pushInsteadOf also to existing pushUris. If some repositories had relied on this mis-feature, pushes may newly suddenly fail (the uncritical case; the config just needs to be fixed) or even still succeed but push to unexpected places, namely to the non-rewritten pushUrls (the critical case). (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=393170\">bug 393170<\/a>)<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-10-04 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.9.0"}],"state":[{"value":"success"}],"title":"4.9.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.9.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.9.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.9.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-08-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tBug Fixes<\/h2>\n<ul><li>\n<p>\t\t\tFix exception handling for opening bitmap index files:<\/p>\n<p>\t\t\tWhen creating a new PackFile instance it may have an associated bitmap index file or not. This information is cached and the JGit assumed a bitmap index file must exist if the cached data tells so. But it may happen that the packfiles are repacked during a gc in a different process causing the packfile, bitmap-index and index file to be deleted. Since JGit still has an open file handle on the packfile this file is still accessible for this JGit proces until the file handle is closed. But index and bitmap index file are deleted and can't be accessed for other processes. Fix getBitmapIndex() to invalidate the cached packfile instance if such a situation occurs.\n\t<\/p><\/li>\n<\/ul>","summary":"","value":"<h2>\r\n\tBug Fixes<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tFix exception handling for opening bitmap index files:<\/div>\r\n\t\t<div>\r\n\t\t\tWhen creating a new PackFile instance it may have an associated bitmap index file or not. This information is cached and the JGit assumed a bitmap index file must exist if the cached data tells so. But it may happen that the packfiles are repacked during a gc in a different process causing the packfile, bitmap-index and index file to be deleted. Since JGit still has an open file handle on the packfile this file is still accessible for this JGit proces until the file handle is closed. But index and bitmap index file are deleted and can&#39;t be accessed for other processes. Fix getBitmapIndex() to invalidate the cached packfile instance if such a situation occurs.<\/div>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[{"format":"full_html","safe_value":"<p>This release is compatible to previous 4.x releases.<\/p>\n<p>Upgrade from the previous simultaneous release (Neon) should work.and JGit follows the rules in <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=509251\">bug 509251<\/a><\/p>\n","value":"<p>This release is compatible to previous 4.x releases.<\/p>\r\n<p>Upgrade from the previous simultaneous release (Neon) should work.and JGit follows the rules in <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=509251\">bug 509251<\/a><\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-06-28 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tAllow DfsReader to be subclassed<\/li>\n<li>\n\t\tTrack read IO statistics for DfsReader<\/li>\n<li>\n\t\tSupport pulling remote branches to apply them on detached HEAD (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=485396\">Bug 485396<\/a>). <\/li>\n<li>\n\t\tReset ObjectWalker when it starts a new walk<\/li>\n<li>\n\t\tClone: add --recurse-submodules option<\/li>\n<li>\n\t\tAdd parseCommit(AnyObjectId) method to Repository.<\/li>\n<li>\n\t\tRepoCommand: Add linkfile support.<\/li>\n<li>\n\t\tBundleWriter: Allow constructing from only an ObjectReader<\/li>\n<li>\n\t\tSupport creating Mergers without a Repository using an ObjectInserter and a config that declares a diff algorithm.<\/li>\n<li>\n\t\tRun auto GC in the background. Execute gc at maximum once per day if number of loose unreachable objects which didn't expire yet exceeds gc.auto limit.<\/li>\n<li>\n\t\tAllow to use an external ExecutorService for background auto-gc<\/li>\n<li>\n\t\tUse a dedicated executor to run auto-gc in command line interface<\/li>\n<li>\n\t\tFetch: Add --recurse-submodules and --no-recurse-submodules options<\/li>\n<\/ul><h2>\n\tPerformance<\/h2>\n<ul><li>\n\t\tExclude refs\/tags from bitmap commit selection to reduce the number of bitmaps created and reduce the memory pressure on the GC task.<\/li>\n<li>\n\t\tReduce fetch bandwidth cost when objects described by the client are missing on the server<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tUpgrade maven plugins<\/li>\n<li>\n\t\tUpdate jetty to 9.4.5 (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=516514\">Bug 516514<\/a>)<\/li>\n<li>\n\t\tUpdate Orbit dependencies to the Oxygen version R20170516192513<\/li>\n<\/ul><h2>\n\t\tBug Fixes<\/h2>\n<ul><li>\n\t\t\tCheckout should not use too long filenames (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=508823\">Bug 508823<\/a>)<\/li>\n<li>\n\t\t\tClean up the disk when cloning fails (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=516303\">Bug 516303<\/a>)<\/li>\n<li>\n\t\t\tAdd shutdown hook to cleanup unfinished clone when JVM is killed (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=516303\">Bug 516303<\/a>)<\/li>\n<li>\n\t\t\tFix stack overflow in MergeBaseGenerator<\/li>\n<li>\n\t\t\tDfsGarbageCollector: Delete expired garbage even when there is no GC pack present.<\/li>\n<li>\n\t\t\tWhen looping through alternates, prevent visiting the same object directory twice.<\/li>\n<li>\n\t\t\tFix RepoCommand to allow for relative URLs<\/li>\n<li>\n\t\t\tPackWriterBitmapWalker: only throw MissingObjectException when necessary <\/li>\n<li>\n\t\t\tArchive TarFormat: Use commit time as timestamp for entries<\/li>\n<li>\n\t\t\tMake diff locations more consistent fixing incorrectly removed or duplicated lines in 3-way merge (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=514095\">Bug 514095<\/a>).<\/li>\n<li>\n\t\t\tFix out-of-bounds exception in RepoCommand#relative<\/li>\n<li>\n\t\t\tFix null return from FS.readPipe when command fails to launch<\/li>\n<\/ul><p> <\/p>\n","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAllow DfsReader to be subclassed<\/li>\r\n\t<li>\r\n\t\tTrack read IO statistics for DfsReader<\/li>\r\n\t<li>\r\n\t\tSupport pulling remote branches to apply them on detached HEAD (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=485396\">Bug 485396<\/a>).&nbsp;<\/li>\r\n\t<li>\r\n\t\tReset ObjectWalker when it starts a new walk<\/li>\r\n\t<li>\r\n\t\tClone: add --recurse-submodules option<\/li>\r\n\t<li>\r\n\t\tAdd parseCommit(AnyObjectId) method to Repository.<\/li>\r\n\t<li>\r\n\t\tRepoCommand: Add linkfile support.<\/li>\r\n\t<li>\r\n\t\tBundleWriter: Allow constructing from only an ObjectReader<\/li>\r\n\t<li>\r\n\t\tSupport creating Mergers without a Repository using an ObjectInserter and a config that declares a diff algorithm.<\/li>\r\n\t<li style=\"box-sizing: border-box;\">\r\n\t\tRun auto GC in the background. Execute gc at maximum once per day if number of loose unreachable objects which didn&#39;t expire yet exceeds gc.auto limit.<\/li>\r\n\t<li style=\"box-sizing: border-box;\">\r\n\t\tAllow to use an external ExecutorService for background auto-gc<\/li>\r\n\t<li style=\"box-sizing: border-box;\">\r\n\t\tUse a dedicated executor to run auto-gc in command line interface<\/li>\r\n\t<li style=\"box-sizing: border-box;\">\r\n\t\tFetch: Add --recurse-submodules and --no-recurse-submodules options<\/li>\r\n<\/ul>\r\n<h2>\r\n\tPerformance<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tExclude refs\/tags from bitmap commit selection to reduce the number of bitmaps created and reduce the memory pressure on the GC task.<\/li>\r\n\t<li>\r\n\t\tReduce fetch bandwidth cost when objects described by the client are missing on the server<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpgrade maven plugins<\/li>\r\n\t<li>\r\n\t\tUpdate jetty to 9.4.5 (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=516514\">Bug 516514<\/a>)<\/li>\r\n\t<li>\r\n\t\tUpdate Orbit dependencies to the Oxygen version R20170516192513<\/li>\r\n<\/ul>\r\n<div>\r\n\t<h2>\r\n\t\tBug Fixes<\/h2>\r\n\t<ul>\r\n\t\t<li>\r\n\t\t\tCheckout should not use too long filenames (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=508823\">Bug 508823<\/a>)<\/li>\r\n\t\t<li>\r\n\t\t\tClean up the disk when cloning fails (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=516303\">Bug 516303<\/a>)<\/li>\r\n\t\t<li>\r\n\t\t\tAdd shutdown hook to cleanup unfinished clone when JVM is killed&nbsp;(<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=516303\">Bug 516303<\/a>)<\/li>\r\n\t\t<li>\r\n\t\t\tFix stack overflow in MergeBaseGenerator<\/li>\r\n\t\t<li>\r\n\t\t\tDfsGarbageCollector: Delete expired garbage even when there is no GC pack present.<\/li>\r\n\t\t<li>\r\n\t\t\tWhen looping through alternates, prevent visiting the same object directory twice.<\/li>\r\n\t\t<li>\r\n\t\t\tFix RepoCommand to allow for relative URLs<\/li>\r\n\t\t<li>\r\n\t\t\tPackWriterBitmapWalker: only throw MissingObjectException when necessary&nbsp;<\/li>\r\n\t\t<li>\r\n\t\t\tArchive TarFormat: Use commit time as timestamp for entries<\/li>\r\n\t\t<li>\r\n\t\t\tMake diff locations more consistent fixing incorrectly removed or duplicated lines in 3-way merge (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=514095\">Bug 514095<\/a>).<\/li>\r\n\t\t<li>\r\n\t\t\tFix out-of-bounds exception in RepoCommand#relative<\/li>\r\n\t\t<li>\r\n\t\t\tFix null return from FS.readPipe when command fails to launch<\/li>\r\n\t<\/ul>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-06-07 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.8.0"}],"state":[{"value":"success"}],"title":"4.8.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.8.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.8.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.8.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-06-07 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tBug Fixes<\/h2>\n<ul><li>\n\t\tArchiveCommand: Create prefix entry with commit time<\/li>\n<li>\n\t\tRun auto GC in the background. Execute gc at maximum once per day if number of loose unreachable objects which didn't expire yet exceeds gc.auto limit.<\/li>\n<li>\n\t\tRepoCommand\n<ul><li>\n\t\t\t\tCleanup and test trailing slash handling in ManifestParser<\/li>\n<li>\n\t\t\t\tManifestParser: Throw exception if remote does not have fetch attribute<\/li>\n<\/ul><\/li>\n<\/ul>","summary":"","value":"<h2>\r\n\tBug Fixes<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tArchiveCommand: Create prefix entry with commit time<\/li>\r\n\t<li>\r\n\t\tRun auto GC in the background. Execute gc at maximum once per day if number of loose unreachable objects which didn&#39;t expire yet exceeds gc.auto limit.<\/li>\r\n\t<li>\r\n\t\tRepoCommand\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tCleanup and test trailing slash handling in ManifestParser<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tManifestParser: Throw exception if remote does not have fetch attribute<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-04-07 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following bug<\/p>\n<ul><li class=\"bugzilla-record bugzilla-Critical bugzilla-fixed bugzilla-resolved\">\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=514170\">514170<\/a> Pack marked as corrupted even if it isn't <\/li>\n<\/ul>","summary":"","value":"<p>This release fixes the following bug<\/p>\r\n<ul>\r\n\t<li class=\"bugzilla-record bugzilla-Critical bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=514170\" style=\"box-sizing: border-box; background-color: transparent; color: rgb(44, 34, 85); text-decoration-line: none; font-weight: bold;\">514170<\/a>&nbsp;Pack marked as corrupted even if it isn&#39;t&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-04-05 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tJGit Features<\/h2>\n<ul><li>\n\t\tFetchCommand: Add basic support for recursing into submodules<\/li>\n<li>\n\t\tPrepare JGit against <a href=\"https:\/\/security.googleblog.com\/2017\/02\/announcing-first-sha1-collision.html\">SHA1 collisions<\/a>\n<ul><li>\n\t\t\t\tSHA-1: collision detection support<\/li>\n<li>\n\t\t\t\tSHA1: support reset() and reuse instances<\/li>\n<li>\n\t\t\t\tSwitch to pure Java SHA1 for ObjectId<\/li>\n<li>\n\t\t\t\tPure Java SHA-1<\/li>\n<\/ul><\/li>\n<li>\n\t\tPullCommand: Allow to set tag behavior<\/li>\n<li>\n\t\tPullCommand: Add support for recursing into submodules<\/li>\n<li>\n\t\tSet commit time in ZipArchiveEntry<\/li>\n<li>\n\t\tLimit receive commands<\/li>\n<li>\n\t\tFollow redirects in transport<\/li>\n<li>\n\t\tNormalizer creating a valid branch name from a string<\/li>\n<li>\n\t\tPack refs\/tags\/ with refs\/heads\/<\/li>\n<li>\n\t\tpush: support per-ref force-with-lease<\/li>\n<li>\n\t\tOnly mark packfile invalid if exception signals permanent problem<\/li>\n<li>\n\t\tDon't flag a packfile invalid if opening existing file failed. Opening a file can fail temporarily if ulimit for open file handles is exceeded.<\/li>\n<\/ul><h2>\n\tGarbage Collection<\/h2>\n<ul><li>\n\t\tGC: don't loosen doomed objects<\/li>\n<li>\n\t\tPrefer smaller GC files during DFS garbage collection<\/li>\n<li>\n\t\tFix missing deltas near type boundaries<\/li>\n<li>\n\t\tReintroduce garbage pack coalescing when ttl &gt; 0.<\/li>\n<li>\n\t\tGC: delete empty directories after purging loose objects<\/li>\n<li>\n\t\tMake GC cancellable when called programmatically<\/li>\n<li>\n\t\tGC.prune(Set&lt;ObjectId&gt;): return early if objects directory is empty<\/li>\n<li>\n\t\tClean up orphan files in GC<\/li>\n<li>\n\t\tGC: loosen unreferenced objects<\/li>\n<li>\n\t\tGC: Add options to preserve and prune old pack files<\/li>\n<\/ul><h2>\n\tLFS Support<\/h2>\n<ul><li>\n\t\tLfsProtocolServlet: Pass HTTP Authorization header to getLargeFileRepository<\/li>\n<li>\n\t\tLfsProtocolServlet#LfsRequest: Add operation type helper methods<\/li>\n<li>\n\t\tExpose LFS operation strings as public constants<\/li>\n<li>\n\t\tLfsProtocolServlet: Improve error on getLargeFileRepository failure<\/li>\n<li>\n\t\tAdd support for refusing LFS request due to invalid authorization<\/li>\n<li>\n\t\tAdd LfsPointerFilter TreeFilter<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tUpgrade error_prone_core to 2.0.18<\/li>\n<li>\n\t\tUpdate Jetty to 9.3.17.v20170317<\/li>\n<li>\n\t\tUpdate com.jcraft.jsch to 0.1.54<\/li>\n<li>\n\t\tUpdate build to use Tycho 1.0.0<\/li>\n<li>\n\t\tFix hamcrest dependency in org.eclipse.jgit.ant.test<\/li>\n<li>\n\t\tUpdate Maven plugins<\/li>\n<li>\n\t\tUpdate Orbit to S20170306214312<\/li>\n<li>\n\t\tImplement <a href=\"https:\/\/bazel.build\/\">Bazel build<\/a><\/li>\n<li>\n\t\tRemove <a href=\"https:\/\/buckbuild.com\/\">buck build<\/a><\/li>\n<\/ul><p>\t <\/p>\n<p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tJGit Features<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tFetchCommand: Add basic support for recursing into submodules<\/li>\r\n\t<li>\r\n\t\tPrepare JGit against <a href=\"https:\/\/security.googleblog.com\/2017\/02\/announcing-first-sha1-collision.html\">SHA1 collisions<\/a>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSHA-1: collision detection support<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSHA1: support reset() and reuse instances<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSwitch to pure Java SHA1 for ObjectId<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tPure Java SHA-1<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tPullCommand: Allow to set tag behavior<\/li>\r\n\t<li>\r\n\t\tPullCommand: Add support for recursing into submodules<\/li>\r\n\t<li>\r\n\t\tSet commit time in ZipArchiveEntry<\/li>\r\n\t<li>\r\n\t\tLimit receive commands<\/li>\r\n\t<li>\r\n\t\tFollow redirects in transport<\/li>\r\n\t<li>\r\n\t\tNormalizer creating a valid branch name from a string<\/li>\r\n\t<li>\r\n\t\tPack refs\/tags\/ with refs\/heads\/<\/li>\r\n\t<li>\r\n\t\tpush: support per-ref force-with-lease<\/li>\r\n\t<li>\r\n\t\tOnly mark packfile invalid if exception signals permanent problem<\/li>\r\n\t<li>\r\n\t\tDon&#39;t flag a packfile invalid if opening existing file failed. Opening a file can fail temporarily if ulimit for open file handles is exceeded.<\/li>\r\n<\/ul>\r\n<h2>\r\n\tGarbage Collection<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tGC: don&#39;t loosen doomed objects<\/li>\r\n\t<li>\r\n\t\tPrefer smaller GC files during DFS garbage collection<\/li>\r\n\t<li>\r\n\t\tFix missing deltas near type boundaries<\/li>\r\n\t<li>\r\n\t\tReintroduce garbage pack coalescing when ttl &gt; 0.<\/li>\r\n\t<li>\r\n\t\tGC: delete empty directories after purging loose objects<\/li>\r\n\t<li>\r\n\t\tMake GC cancellable when called programmatically<\/li>\r\n\t<li>\r\n\t\tGC.prune(Set&lt;ObjectId&gt;): return early if objects directory is empty<\/li>\r\n\t<li>\r\n\t\tClean up orphan files in GC<\/li>\r\n\t<li>\r\n\t\tGC: loosen unreferenced objects<\/li>\r\n\t<li>\r\n\t\tGC: Add options to preserve and prune old pack files<\/li>\r\n<\/ul>\r\n<h2>\r\n\tLFS Support<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tLfsProtocolServlet: Pass HTTP Authorization header to getLargeFileRepository<\/li>\r\n\t<li>\r\n\t\tLfsProtocolServlet#LfsRequest: Add operation type helper methods<\/li>\r\n\t<li>\r\n\t\tExpose LFS operation strings as public constants<\/li>\r\n\t<li>\r\n\t\tLfsProtocolServlet: Improve error on getLargeFileRepository failure<\/li>\r\n\t<li>\r\n\t\tAdd support for refusing LFS request due to invalid authorization<\/li>\r\n\t<li>\r\n\t\tAdd LfsPointerFilter TreeFilter<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpgrade error_prone_core to 2.0.18<\/li>\r\n\t<li>\r\n\t\tUpdate Jetty to 9.3.17.v20170317<\/li>\r\n\t<li>\r\n\t\tUpdate com.jcraft.jsch to 0.1.54<\/li>\r\n\t<li>\r\n\t\tUpdate build to use Tycho 1.0.0<\/li>\r\n\t<li>\r\n\t\tFix hamcrest dependency in org.eclipse.jgit.ant.test<\/li>\r\n\t<li>\r\n\t\tUpdate Maven plugins<\/li>\r\n\t<li>\r\n\t\tUpdate Orbit to S20170306214312<\/li>\r\n\t<li>\r\n\t\tImplement <a href=\"https:\/\/bazel.build\/\">Bazel build<\/a><\/li>\r\n\t<li>\r\n\t\tRemove <a href=\"https:\/\/buckbuild.com\/\">buck build<\/a><\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-03-29 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.7.0"}],"state":[{"value":"success"}],"title":"4.7.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.7.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.7.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.7.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-03-22 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following bugs:<\/p>\n<ul><li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved\">\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=501211\">501211<\/a> LogCommand fails to compute correct history if called too fast after commit <\/li>\n<li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved\">\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=502107\">502107<\/a> MissingResourceException: key usage_clean <\/li>\n<li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved\">\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=503010\">503010<\/a> jgit-cli.jar should not contain junit classes <\/li>\n<li class=\"bugzilla-record bugzilla-Blocker bugzilla-fixed bugzilla-resolved\">\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=513435\">513435<\/a> Don't remove Pack when FileNotFoundException is transient<\/li>\n<\/ul>","summary":"","value":"<p>This release fixes the following bugs:<\/p>\r\n<ul>\r\n\t<li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=501211\" style=\"box-sizing: border-box; background-color: transparent; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold;\">501211<\/a>&nbsp;LogCommand fails to compute correct history if called too fast after commit&nbsp;<\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=502107\" style=\"box-sizing: border-box; background-color: transparent; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold;\">502107<\/a>&nbsp;MissingResourceException: key usage_clean&nbsp;<\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=503010\" style=\"box-sizing: border-box; background-color: transparent; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold;\">503010<\/a>&nbsp;jgit-cli.<wbr style=\"box-sizing: border-box;\" \/>jar should not contain junit classes&nbsp;<\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Blocker bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=513435\" style=\"box-sizing: border-box; background-color: transparent; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold;\">513435<\/a>&nbsp;Don&#39;t remove Pack when FileNotFoundException is transient<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-03-07 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tBug fixes<\/h2>\n<ul><li>\n\t\t\tGC: delete empty directories after purging loose objects<\/li>\n<li>\n\t\t\tGC.prune(Set&lt;ObjectId&gt;): return early if objects directory is empty<\/li>\n<li>\n\t\t\tClean up orphan files in GC<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tUpdate Jetty to 9.4.1.v20170120<\/li>\n<li>\n\t\tUpdate build to use Tycho 1.0.0<\/li>\n<li>\n\t\tUpdate Orbit to S20170120205402 and com.jcraft.jsch to 0.1.54<\/li>\n<li>\n\t\tUpdate maven plugins<\/li>\n<\/ul>","summary":"","value":"<h2>\r\n\tBug fixes<\/h2>\r\n<div>\r\n\t<ul>\r\n\t\t<li>\r\n\t\t\tGC: delete empty directories after purging loose objects<\/li>\r\n\t\t<li>\r\n\t\t\tGC.prune(Set&lt;ObjectId&gt;): return early if objects directory is empty<\/li>\r\n\t\t<li>\r\n\t\t\tClean up orphan files in GC<\/li>\r\n\t<\/ul>\r\n<\/div>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpdate Jetty to 9.4.1.v20170120<\/li>\r\n\t<li>\r\n\t\tUpdate build to use Tycho 1.0.0<\/li>\r\n\t<li>\r\n\t\tUpdate Orbit to S20170120205402 and com.jcraft.jsch to 0.1.54<\/li>\r\n\t<li>\r\n\t\tUpdate maven plugins<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.6.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.6.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-12-21 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tImplement auto gc<\/li>\n<li>\n\t\tCheckoutCommand: Add method to add multiple paths<\/li>\n<li>\n\t\tAdd \"concurrencyLevel\" option to DfsBlockCache<\/li>\n<li>\n\t\tAdd ReceivedPackStatistics for PackParser<\/li>\n<\/ul><h2>\n\tJGit Command Line<\/h2>\n<ul><li>\n\t\tCheckout: Add the ability to checkout all paths.<\/li>\n<\/ul><h2>\n\tLFS Support<\/h2>\n<ul><li>\n\t\tAdd built-in LFS smudge filter for local case<\/li>\n<li>\n\t\tAdd built-in LFS clean filter<\/li>\n<li>\n\t\tAdd configuration parameter to enable built-in hooks\/filters<\/li>\n<li>\n\t\tAdd support for built-in smudge filters<\/li>\n<li>\n\t\tAdd support for built-in clean filters<\/li>\n<\/ul><h2>\n\tJGit Ketch<\/h2>\n<ul><li>\n\t\tDefine MonotonicClock interface for advanced timestamps<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tUpdate JGit minimum execution environment to JavaSE-1.8<\/li>\n<li>\n\t\tUpdate JavaEWAH to 1.1.6<\/li>\n<li>\n\t\tAdd Oxygen target platform and remove target platforms older than Mars<\/li>\n<li>\n\t\tBuck build: upgrade buck to latest version<\/li>\n<li>\n\t\tConfigure Maven to run tests concurrently by default<\/li>\n<li>\n\t\tEnable error-prone for the Maven build<\/li>\n<li>\n\t\tUse consistent feature and category names<\/li>\n<\/ul><p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tImplement auto gc<\/li>\r\n\t<li>\r\n\t\tCheckoutCommand: Add method to add multiple paths<\/li>\r\n\t<li>\r\n\t\tAdd &quot;concurrencyLevel&quot; option to DfsBlockCache<\/li>\r\n\t<li>\r\n\t\tAdd ReceivedPackStatistics for PackParser<\/li>\r\n<\/ul>\r\n<h2>\r\n\tJGit Command Line<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tCheckout: Add the ability to checkout all paths.<\/li>\r\n<\/ul>\r\n<h2>\r\n\tLFS Support<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdd built-in LFS smudge filter for local case<\/li>\r\n\t<li>\r\n\t\tAdd built-in LFS clean filter<\/li>\r\n\t<li>\r\n\t\tAdd configuration parameter to enable built-in hooks\/filters<\/li>\r\n\t<li>\r\n\t\tAdd support for built-in smudge filters<\/li>\r\n\t<li>\r\n\t\tAdd support for built-in clean filters<\/li>\r\n<\/ul>\r\n<h2>\r\n\tJGit Ketch<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tDefine MonotonicClock interface for advanced timestamps<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpdate JGit minimum execution environment to JavaSE-1.8<\/li>\r\n\t<li>\r\n\t\tUpdate JavaEWAH to 1.1.6<\/li>\r\n\t<li>\r\n\t\tAdd Oxygen target platform and remove target platforms older than Mars<\/li>\r\n\t<li>\r\n\t\tBuck build: upgrade buck to latest version<\/li>\r\n\t<li>\r\n\t\tConfigure Maven to run tests concurrently by default<\/li>\r\n\t<li>\r\n\t\tEnable error-prone for the Maven build<\/li>\r\n\t<li>\r\n\t\tUse consistent feature and category names<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-12-21 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.6"}],"state":[{"value":"success"}],"title":"4.6 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.6-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.6","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.6","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-09-21 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tPush implementation of option strings.<br \/>\n\t\tExample usage:<br \/>\n\t\t    $ .\/jgit push \\<br \/>\n\t\t      --push-option \"Reviewer=jZrFr4xZ3yWPFPH2@M2z16HxesfHKcOwC\" \\<br \/>\n\t\t      --push-option \"&lt;arbitrary string&gt;\" \\<br \/>\n\t\t      origin HEAD:refs\/for\/master<br \/>\n\t\tPush options were also <a href=\"http:\/\/marc.info\/?l=git&amp;m=146853299804147&amp;w=2\">added to cgit<\/a><\/li>\n<li>\n\t\tPacket logging for JGit<br \/>\n\t\tImitate the packet tracing feature from C Git. Unlike C Git, use the log4j<br \/>\n\t\tlog level setting instead of the GIT_TRACE_PACKET environment variable<br \/>\n\t\tto enable tracing. Use as follows:<br \/>\n\t\t1. Enable tracing by adding the lines<br \/>\n\t\t        log4j.logger.org.eclipse.jgit.transport=DEBUG, stderr<br \/>\n\t\t        log4j.additivity.org.eclipse.jgit.transport=false<br \/>\n\t\t    to org.eclipse.jgit.pgm\/resources\/log4j.properties.<br \/>\n\t\t2. mvn package<br \/>\n\t\t3. org.eclipse.jgit.pgm\/target\/jgit \\<br \/>\n\t\t        ls-remote git:\/\/git.kernel.org\/pub\/scm\/git\/git 2&gt;&amp;1 | less<br \/>\n\t\tThen the output provides a trace of packets sent and received over the wire<\/li>\n<li>\n\t\tShallow fetch\/clone: Make --depth mean the total history depth<br \/>\n\t\tcgit changed the --depth parameter to mean the total depth of history<br \/>\n\t\trather than the depth of ancestors to be returned. JGit still uses<br \/>\n\t\tthe latter meaning, so update it to match cgit.<\/li>\n<li>\n\t\tShallow fetch: Respect \"shallow\" lines<\/li>\n<li>\n\t\tReceivePack: report protocol parsing failures on channel 3<\/li>\n<li>\n\t\tPush: Report fatal server errors during pack writing<\/li>\n<li>\n\t\tAdd configureJSch() method to allow configuration of JSch objects<\/li>\n<li>\n\t\tAdd support for post-commit hooks<\/li>\n<li>\n\t\tEnhance ResetCommand to allow disabling reflog update<\/li>\n<\/ul><h2>\n\tJGit Command Line<\/h2>\n<ul><li>\n\t\tAdded a clean command.<\/li>\n<li>\n\t\tTag command: implement option -d for deleting tags<\/li>\n<\/ul><h2>\n\tLFS<\/h2>\n<ul><li>\n\t\timprove exception handling in LfsProtocolServlet<\/li>\n<\/ul><p>\t <\/p>\n<p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tPush implementation of option strings.<br \/>\r\n\t\tExample usage:<br \/>\r\n\t\t&nbsp; &nbsp; $ .\/jgit push \\<br \/>\r\n\t\t&nbsp; &nbsp; &nbsp; --push-option &quot;Reviewer=jZrFr4xZ3yWPFPH2@M2z16HxesfHKcOwC&quot; \\<br \/>\r\n\t\t&nbsp; &nbsp; &nbsp; --push-option &quot;&lt;arbitrary string&gt;&quot; \\<br \/>\r\n\t\t&nbsp; &nbsp; &nbsp; origin HEAD:refs\/for\/master<br \/>\r\n\t\tPush options were also <a href=\"http:\/\/marc.info\/?l=git&amp;m=146853299804147&amp;w=2\">added to cgit<\/a><\/li>\r\n\t<li>\r\n\t\tPacket logging for JGit<br \/>\r\n\t\tImitate the packet tracing feature from C Git. Unlike C Git, use the log4j<br \/>\r\n\t\tlog level setting instead of the GIT_TRACE_PACKET environment variable<br \/>\r\n\t\tto enable tracing.&nbsp;Use as follows:<br \/>\r\n\t\t1. Enable tracing by adding the lines<br \/>\r\n\t\t&nbsp; &nbsp; &nbsp; &nbsp; log4j.logger.org.eclipse.jgit.transport=DEBUG, stderr<br \/>\r\n\t\t&nbsp; &nbsp; &nbsp; &nbsp; log4j.additivity.org.eclipse.jgit.transport=false<br \/>\r\n\t\t&nbsp; &nbsp; to org.eclipse.jgit.pgm\/resources\/log4j.properties.<br \/>\r\n\t\t2. mvn package<br \/>\r\n\t\t3. org.eclipse.jgit.pgm\/target\/jgit \\<br \/>\r\n\t\t&nbsp; &nbsp; &nbsp; &nbsp; ls-remote git:\/\/git.kernel.org\/pub\/scm\/git\/git 2&gt;&amp;1 | less<br \/>\r\n\t\tThen the output provides a trace of packets sent and received over&nbsp;the wire<\/li>\r\n\t<li>\r\n\t\tShallow fetch\/clone: Make --depth mean the total history depth<br \/>\r\n\t\tcgit changed the --depth parameter to mean the total depth of history<br \/>\r\n\t\trather than the depth of ancestors to be returned. JGit still uses<br \/>\r\n\t\tthe latter meaning, so update it to match cgit.<\/li>\r\n\t<li>\r\n\t\tShallow fetch: Respect &quot;shallow&quot; lines<\/li>\r\n\t<li>\r\n\t\tReceivePack: report protocol parsing failures on channel 3<\/li>\r\n\t<li>\r\n\t\tPush: Report fatal server errors during pack writing<\/li>\r\n\t<li>\r\n\t\tAdd configureJSch() method to allow configuration of JSch objects<\/li>\r\n\t<li>\r\n\t\tAdd support for post-commit hooks<\/li>\r\n\t<li>\r\n\t\tEnhance ResetCommand to allow disabling reflog update<\/li>\r\n<\/ul>\r\n<h2>\r\n\tJGit Command Line<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdded a clean command.<\/li>\r\n\t<li>\r\n\t\tTag command: implement option -d for deleting tags<\/li>\r\n<\/ul>\r\n<h2>\r\n\tLFS<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\timprove exception handling in LfsProtocolServlet<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-09-21 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.5"}],"state":[{"value":"success"}],"title":"4.5 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.5-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.5","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.5","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-07-15 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h3>\n\tThis release fixes the following bugs<\/h3>\n<ul><li class=\"bugzilla-record bugzilla-Major bugzilla-fixed bugzilla-resolved\">\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=495505\">495505<\/a> include.path fails if specified file does not exist <\/p>\n<\/li>\n<li class=\"bugzilla-record bugzilla-Major bugzilla-fixed bugzilla-resolved\">\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=496262\">496262<\/a> Using JGit in with Java 7 may cause java.lang.NoSuchMethodError: java.util.concurrent.ConcurrentHashMap.keySet()...<\/p>\n<\/li>\n<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=496732\">496732<\/a> jgit 4.4 fails reading git config with include <\/p>\n<\/li>\n<\/ul><h3 class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">\n\tImplement a time based eviction strategy for RepositoryCache.<\/h3>\n<p class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">When Repository.close() decrements the useCount to 0 currently the cache immediately evicted the repository<br \/>\n\tfrom WindowCache and RepositoryCache. This led to I\/O overhead on busy repositories because pack files and references<br \/>\n\tare inserted and deleted from the cache frequently. This fix defers the eviction of a repository from the caches until last use<br \/>\n\tof the repository is older than time to live. The eviction is handled by a background task running periodically. <\/p>\n<p class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">Add two new configuration parameters: <\/p>\n<ul><li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">\n\t\tcore.repositoryCacheExpireAfter: cache entries are evicted if the cache entry wasn't accessed longer than this time in<br \/>\n\t\tmilliseconds or use any of the supported time units<\/li>\n<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">\n\t\tcore.repositoryCacheCleanupDelay: defines the interval in milliseconds or any of the supported time units<br \/>\n\t\tfor running a background task evicting expired cache entries.<br \/>\n\t\tIf set to -1 the delay is set to min(repositoryCacheExpireAfter, 10 minutes).<br \/>\n\t\tIf set to 0 the time based eviction is switched off and no background task is started.<br \/>\n\t\tIf time based eviction is switched off the JVM can still evict cache entries if heap memory is running low.<\/li>\n<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\">\n<p>Time units supported: <br \/>\n\t\t\t-  milliseconds (1 ms, 2 milliseconds)<br \/>\n\t\t\t- seconds (1 s, 1 sec, 1 second, 2 seconds)<br \/>\n\t\t\t- minutes (1 m, 1 min, 1 minute, 2 minutes)<br \/>\n\t\t\t- hours (1 h, 1 hr, 1 hour, 2 hours)<br \/>\n\t\t\t- days (1 d, 1 day, 2 days)<br \/>\n\t\t\t- weeks (1 w, 1 week, 2 weeks)<br \/>\n\t\t\t- months (1 mon, 1 month, 2 months)<br \/>\n\t\t\t- years (1 y, 1 year, 2 years)<\/p>\n<\/li>\n<\/ul>","summary":"","value":"<h3>\r\n\tThis release fixes the following bugs<\/h3>\r\n<ul>\r\n\t<li class=\"bugzilla-record bugzilla-Major bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=495505\" style=\"box-sizing: border-box; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold; background-color: transparent;\">495505<\/a>&nbsp;include.<wbr style=\"box-sizing: border-box;\" \/>path fails if specified file does not exist&nbsp;<\/p>\r\n\t<\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Major bugzilla-fixed bugzilla-resolved\" style=\"box-sizing: border-box;\">\r\n\t\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=496262\" style=\"box-sizing: border-box; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold; background-color: transparent;\">496262<\/a>&nbsp;Using JGit in with Java 7 may cause java.<wbr style=\"box-sizing: border-box;\" \/>lang.<wbr style=\"box-sizing: border-box;\" \/>NoSuchMethodError: java.<wbr style=\"box-sizing: border-box;\" \/>util.<wbr style=\"box-sizing: border-box;\" \/>concurrent.<wbr style=\"box-sizing: border-box;\" \/>ConcurrentHashMap.keySet().<wbr style=\"box-sizing: border-box;\" \/>.<wbr style=\"box-sizing: border-box;\" \/>.<wbr style=\"box-sizing: border-box;\" \/><\/p>\r\n\t<\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=496732\" style=\"box-sizing: border-box; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold; background-color: transparent;\">496732<\/a>&nbsp;jgit 4.<wbr style=\"box-sizing: border-box;\" \/>4 fails reading git config with include&nbsp;<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<h3 class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\tImplement a time based eviction strategy for RepositoryCache.<\/h3>\r\n<p class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\"><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"color: rgb(53, 53, 53); font-size: small; white-space: pre;\">When Repository.close() decrements the useCount to 0 currently the cache immediately evicted the repository<\/span><\/span><br \/>\r\n\t<span style=\"color: rgb(53, 53, 53); font-family: arial, helvetica, sans-serif; font-size: small; white-space: pre;\">from WindowCache and RepositoryCache. This led to I\/O overhead on busy repositories because pack files and references<br \/>\r\n\t<span style=\"color: rgb(53, 53, 53); font-family: arial, helvetica, sans-serif; font-size: small; white-space: pre;\">are inserted and deleted from the cache frequently. This fix defers the eviction of a repository from the caches until last use<\/span><\/span><br \/>\r\n\t<span style=\"color: rgb(53, 53, 53); font-family: arial, helvetica, sans-serif; font-size: small; white-space: pre;\">of the repository is older than time to live. The eviction is handled by a background task running periodically. <\/span><\/p>\r\n<p class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\"><span style=\"color: rgb(53, 53, 53); font-family: arial, helvetica, sans-serif; font-size: small; white-space: pre;\">Add two new configuration parameters: <\/span><\/p>\r\n<ul>\r\n\t<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<span style=\"color: rgb(53, 53, 53); font-family: arial, helvetica, sans-serif; font-size: small; white-space: pre;\"><span style=\"font-family:courier new,courier,monospace;\">core.repositoryCacheExpireAfter<\/span>: cache entries are evicted if the cache entry wasn&#39;t accessed longer than this time in<br \/>\r\n\t\tmilliseconds or use any of the supported time units<\/span><\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<span style=\"color: rgb(53, 53, 53); font-family: arial, helvetica, sans-serif; font-size: small; white-space: pre;\"><span style=\"font-family:courier new,courier,monospace;\">core.repositoryCacheCleanupDelay<\/span>: defines the interval in milliseconds or any of the supported time units<br \/>\r\n\t\tfor running a background task evicting expired cache entries.<br \/>\r\n\t\tIf set to -1 the delay is set to <span style=\"font-family:courier new,courier,monospace;\">min(repositoryCacheExpireAfter, 10 minutes)<\/span>.<br \/>\r\n\t\tIf set to 0 the time based eviction is switched off and no background task is started.<br \/>\r\n\t\tIf time based eviction is switched off the JVM can still evict cache entries if heap memory is running low.<\/span><\/li>\r\n\t<li class=\"bugzilla-record bugzilla-Major bugzilla-unresolved bugzilla-new\" style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"color: rgb(53, 53, 53); font-size: small; white-space: pre;\">Time units supported: <\/span><\/span><br \/>\r\n\t\t\t- &nbsp;<span style=\"color: rgb(53, 53, 53); font-size: small; white-space: pre;\"><span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">milliseconds (1 ms, 2 milliseconds)<br \/>\r\n\t\t\t- <span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">seconds (1 s, 1 sec, 1 second, 2 seconds)<br \/>\r\n\t\t\t- <span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">minutes (1 m, 1 min, 1 minute, 2 minutes)<br \/>\r\n\t\t\t- <span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">hours (1 h, 1 hr, 1 hour, 2 hours)<br \/>\r\n\t\t\t<span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">- days (1 d, 1 day, 2 days)<br \/>\r\n\t\t\t- <span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">weeks (1 w, 1 week, 2 weeks)<br \/>\r\n\t\t\t- <span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">months (1 mon, 1 month, 2 months)<br \/>\r\n\t\t\t- <span style=\"color: rgb(53, 53, 53); font-family: monospace; font-size: small; white-space: pre;\">years (1 y, 1 year, 2 years)<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.4.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.4.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-06-22 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>4.0 was shipped with Mars and we release every 3 months.<br \/>\n\t5.0 will include the features from releases 4.1 - 4.3.<\/p>\n<p>API Cleanup<\/p>\n<ul><li>\n<p>remove deprecated API<\/p>\n<\/li>\n<\/ul><p>Breaking Changes<\/p>\n<ul><li>\n\t\tto be done<\/li>\n<\/ul><p> <\/p>\n<ul><\/ul><p>\t <\/p>\n","value":"<p style=\"box-sizing: border-box; margin: 0px 0px 10px; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 18.1818px;\">4.0 was shipped with Mars and we release every 3 months.<br style=\"box-sizing: border-box;\" \/>\r\n\t5.0 will include the features from releases 4.1 - 4.3.<\/p>\r\n<p style=\"box-sizing: border-box; margin: 0px 0px 10px; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 18.1818px;\">API Cleanup<\/p>\r\n<ul style=\"box-sizing: border-box; margin-top: 0px; margin-bottom: 10px; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 18.1818px;\">\r\n\t<li style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<p>remove deprecated API<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p style=\"box-sizing: border-box; padding-bottom: 7px;\"><span style=\"line-height: 18.1818px;\">Breaking Changes<\/span><\/p>\r\n<ul>\r\n\t<li style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<span style=\"line-height: 18.1818px;\">to be done<\/span><\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n<ul style=\"box-sizing: border-box; margin-top: 0px; margin-bottom: 10px; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 18.1818px;\">\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tJGit command line: allow to call git init with specific directory<\/li>\n<li>\n\t\tSupport git config [include] section with absolute path<\/li>\n<li>\n\t\tLogCommand: enable to set filter to only show merge or non-merge commits<\/li>\n<li>\n\t\tApplyCommand: Allow setting FileMode to executable when applying patches<\/li>\n<li>\n\t\tMake BaseReceivePack.setAtomic public<\/li>\n<li>\n\t\tSupport per-BatchRefUpdate atomic transactions<\/li>\n<li>\n\t\tExpose conflicting files in CheckoutConflictException<\/li>\n<\/ul><h2>\n\tReleng<\/h2>\n<ul><li>\n\t\tUpdated Maven plugins<\/li>\n<\/ul><p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tJGit command line: allow to call git init with specific directory<\/li>\r\n\t<li>\r\n\t\tSupport git config [include] section with absolute path<\/li>\r\n\t<li>\r\n\t\tLogCommand: enable to set filter to only show merge or non-merge commits<\/li>\r\n\t<li>\r\n\t\tApplyCommand: Allow setting FileMode to executable when applying patches<\/li>\r\n\t<li>\r\n\t\tMake BaseReceivePack.setAtomic public<\/li>\r\n\t<li>\r\n\t\tSupport per-BatchRefUpdate atomic transactions<\/li>\r\n\t<li>\r\n\t\tExpose conflicting files in CheckoutConflictException<\/li>\r\n<\/ul>\r\n<h2>\r\n\tReleng<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpdated Maven plugins<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-06-01 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.4"}],"state":[{"value":"success"}],"title":"4.4 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.4-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.4","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.4","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-05-05 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following issues:<\/p>\n<p>\t* Scan loose ref before packed in case gc is about to remove the loose refs<\/p>\n<p>\t* Fix possible NPEs when reporting transport errors<\/p>\n<p>\t* <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=491505\">Bug 491505<\/a>: Fix calling of clean\/smudge filters from CheckoutCommand and MergeCommand<\/p>\n<p>\t* Fix ApplyCommand when result of patch is an empty file<\/p>\n","summary":"","value":"<p>This release fixes the following issues:<\/p>\r\n<div>\r\n\t* Scan loose ref before packed in case gc is about to remove the loose refs<\/div>\r\n<div>\r\n\t* Fix possible NPEs when reporting transport errors<\/div>\r\n<div>\r\n\t* <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=491505\">Bug 491505<\/a>:&nbsp;Fix calling of clean\/smudge filters from CheckoutCommand and MergeCommand<\/div>\r\n<div>\r\n\t* Fix ApplyCommand when result of patch is an empty file<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.3.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.3.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-04-06 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tGit attributes support<\/h2>\n<p>Implement git attributes support for<\/p>\n<ul><li>\n\t\ttext attributes<\/li>\n<li>\n\t\teol attributes<\/li>\n<li>\n\t\tmacros<\/li>\n<li>\n\t\tbinary macro<\/li>\n<\/ul><h2>\n\tLarge File Storage (LFS) Extension<\/h2>\n<p><a href=\"https:\/\/git-lfs.github.com\/\">Git Large File Storage (LFS)<\/a> is a Git extension for versioning large files<\/p>\n<p>\tLFS replaces large files such as audio samples, videos, datasets, and graphics with text pointers inside Git, while storing the file contents on a remote LFS server.<\/p>\n<p>\t <\/p>\n<p>\tIn 4.3 the following features to support LFS in JGit were implemented<\/p>\n<ul><li>\n\t\tSHA-256 abstraction<\/li>\n<li>\n\t\tcommand line command <em>debug-lfs-store<\/em> to run LFS test server<\/li>\n<li>\n\t\tLFS server: support LFS protocol and a file system based LFS storage (used in Gerrit <a href=\"https:\/\/gerrit.googlesource.com\/plugins\/lfs-storage-fs\/\"><em>lfs-storage-fs<\/em> plugin<\/a>)<\/li>\n<li>\n\t\tLFS server: support Amazon S3 based storage for LFS (used in Gerrit <a href=\"https:\/\/gerrit.googlesource.com\/plugins\/lfs-storage-s3\/\"><em>lfs-storage-s3<\/em> plugin<\/a>)<\/li>\n<li>\n\t\tfix FileLfsRepository to make it thread safe<\/li>\n<\/ul><h2>\n\tRefTree<\/h2>\n<p>\tRefTree enables JGit to version refs (branches, tags and symbolic refs) in a Git tree and enables atomic push which is a precondition to implement Git Ketch.<\/p>\n<p>\t <\/p>\n<p>\tA group of updates can be applied by updating the tree in one step, writing out a new root tree, and storing its SHA-1. If references are stored in RefTrees, comparing two repositories is a matter of checking if two SHA-1s are identical. Without RefTrees comparing two repositories requires listing all references and comparing the sets.<\/p>\n<p>\t <\/p>\n<p>\tTrack the \"refs\/\" directory as a root tree by storing references that point directly at an object as a GITLINK entry in the tree. For example \"refs\/heads\/master\" is written as \"heads\/master\".<\/p>\n<p>\t <\/p>\n<p>\tAnnotated tags also store their peeled value with ^{} suffix, using \"tags\/v1.0\" and \"tags\/v1.0^{}\" GITLINK entries.<\/p>\n<p>\t <\/p>\n<p>\tSymbolic references are written as SYMLINK entries with the blob of the symlink carrying the name of the symbolic reference target.<\/p>\n<p>\t <\/p>\n<p>\tHEAD is outside of \"refs\/\" namespace so it is stored as a special \"..HEAD\" entry.<\/p>\n<ul><li>\n\t\t<em>debug-rebuild-ref-tree<\/em> command line command to migrate refs to RefTreeDatabase<\/li>\n<li>\n\t\tcopy HEAD into RefTree<\/li>\n<li>\n\t\tRefTreeDatabase: Allow ORIG_HEAD, etc. on non-bare repositories<\/li>\n<li>\n\t\tRefTreeDatabase: Expose bootstrap refs in getAdditionalRefs<\/li>\n<\/ul><h2>\n\tGit Ketch<\/h2>\n<p>\t\tGit Ketch is a multi-master Git repository management system.  Writes are successful only if a majority of participant servers agree. Acknowledged writes are durable against server failures as a majority of the participants store all required objects.<\/p>\n<p>\t\t <\/p>\n<p>\t\tGit Ketch is modeled on the <a href=\"https:\/\/raft.github.io\/\">Raft Consensus Algorithm<\/a>.  A ketch sailing vessel is faster and more nimble than a raft.  It can also carry more source codes. Git Ketch front-loads replication costs, which vaguely resembles a ketch sailing vessel's distinguishing feature of the main mast on the front of the ship.<\/p>\n<p>\t\t <\/p>\n<p>\tIn 4.3 the following Ketch features were implemented<\/p>\n<ul><li>\n\t\tbasic replication system<\/li>\n<li>\n\t\tsimple map of running leader instances<\/li>\n<li>\n\t\tintercept push and route it through Ketch<\/li>\n<li>\n\t\tdaemon: Add --ketch=LEADER flag<\/li>\n<\/ul><h2>\n\tRepo command<\/h2>\n<ul><li>\n\t\tadd ignoreRemoteFailures option to RepoCommand<\/li>\n<li>\n\t\tsupport revision in remote tag<\/li>\n<\/ul><h2>\n\tMiscellaneous<\/h2>\n<ul><li>\n\t\timplement configuration option DIR_NO_GITLINKS<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tEnable building JGit and Gerrit in the same Buck build to speed up build for features spanning JGit and Gerrit<\/li>\n<\/ul><p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tGit attributes support<\/h2>\r\n<p>Implement git attributes support for<\/p>\r\n<ul>\r\n\t<li>\r\n\t\ttext attributes<\/li>\r\n\t<li>\r\n\t\teol attributes<\/li>\r\n\t<li>\r\n\t\tmacros<\/li>\r\n\t<li>\r\n\t\tbinary macro<\/li>\r\n<\/ul>\r\n<h2>\r\n\tLarge File Storage (LFS) Extension<\/h2>\r\n<p><a href=\"https:\/\/git-lfs.github.com\/\">Git Large File Storage (LFS)<\/a> is a Git extension for versioning large files<\/p>\r\n<div>\r\n\tLFS replaces large files such as audio samples, videos, datasets, and graphics with text pointers inside Git, while storing the file contents on a remote LFS server.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tIn 4.3 the following features to support LFS in JGit were implemented<\/div>\r\n<ul>\r\n\t<li>\r\n\t\tSHA-256 abstraction<\/li>\r\n\t<li>\r\n\t\tcommand line command <em>debug-lfs-store<\/em> to run LFS test server<\/li>\r\n\t<li>\r\n\t\tLFS server: support LFS protocol and a file system based LFS storage (used in Gerrit <a href=\"https:\/\/gerrit.googlesource.com\/plugins\/lfs-storage-fs\/\"><em>lfs-storage-fs<\/em> plugin<\/a>)<\/li>\r\n\t<li>\r\n\t\tLFS server: support Amazon S3 based storage for LFS (used in Gerrit <a href=\"https:\/\/gerrit.googlesource.com\/plugins\/lfs-storage-s3\/\"><em>lfs-storage-s3<\/em> plugin<\/a>)<\/li>\r\n\t<li>\r\n\t\tfix FileLfsRepository to make it thread safe<\/li>\r\n<\/ul>\r\n<h2>\r\n\tRefTree<\/h2>\r\n<div>\r\n\tRefTree enables JGit to version refs (branches, tags and symbolic refs) in a Git tree and enables atomic push which is a precondition to implement Git Ketch.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tA group of updates can be applied by updating the tree in one step, writing out a new root tree, and storing its SHA-1. If references are stored in RefTrees, comparing two repositories is a matter of checking if two SHA-1s are identical. Without RefTrees comparing two repositories requires listing all references and comparing the sets.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tTrack the &quot;refs\/&quot; directory as a root tree by storing references that point directly at an object as a GITLINK entry in the tree. For example &quot;refs\/heads\/master&quot; is written as &quot;heads\/master&quot;.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tAnnotated tags also store their peeled value with ^{} suffix, using &quot;tags\/v1.0&quot; and &quot;tags\/v1.0^{}&quot; GITLINK entries.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tSymbolic references are written as SYMLINK entries with the blob of the symlink carrying the name of the symbolic reference target.<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tHEAD is outside of &quot;refs\/&quot; namespace so it is stored as a special &quot;..HEAD&quot; entry.<\/div>\r\n<ul>\r\n\t<li>\r\n\t\t<em>debug-rebuild-ref-tree<\/em> command line command to migrate refs to RefTreeDatabase<\/li>\r\n\t<li>\r\n\t\tcopy HEAD into RefTree<\/li>\r\n\t<li>\r\n\t\tRefTreeDatabase: Allow ORIG_HEAD, etc. on non-bare repositories<\/li>\r\n\t<li>\r\n\t\tRefTreeDatabase: Expose bootstrap refs in getAdditionalRefs<\/li>\r\n<\/ul>\r\n<h2>\r\n\tGit Ketch<\/h2>\r\n<div>\r\n\t<div>\r\n\t\tGit Ketch is a multi-master Git repository management system. &nbsp;Writes are successful only if a majority of participant servers agree. Acknowledged writes are durable against server failures as a majority of the participants store all required objects.<\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n\t<div>\r\n\t\tGit Ketch is modeled on the <a href=\"https:\/\/raft.github.io\/\">Raft Consensus Algorithm<\/a>. &nbsp;A ketch sailing vessel is faster and more nimble than a raft. &nbsp;It can also carry more source codes. Git Ketch front-loads replication costs, which vaguely resembles a ketch sailing vessel&#39;s distinguishing feature of the main mast on the front of the ship.<\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n<\/div>\r\n<div>\r\n\tIn 4.3 the following Ketch features were implemented<\/div>\r\n<ul>\r\n\t<li>\r\n\t\tbasic replication system<\/li>\r\n\t<li>\r\n\t\tsimple map of running leader instances<\/li>\r\n\t<li>\r\n\t\tintercept push and route it through Ketch<\/li>\r\n\t<li>\r\n\t\tdaemon: Add --ketch=LEADER flag<\/li>\r\n<\/ul>\r\n<h2>\r\n\tRepo command<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tadd ignoreRemoteFailures option to RepoCommand<\/li>\r\n\t<li>\r\n\t\tsupport revision in remote tag<\/li>\r\n<\/ul>\r\n<h2>\r\n\tMiscellaneous<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\timplement configuration option DIR_NO_GITLINKS<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tEnable building JGit and Gerrit in the same Buck build to speed up build for features spanning JGit and Gerrit<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-04-06 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.3"}],"state":[{"value":"success"}],"title":"4.3 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.3-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.3","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-01-20 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tAPI<\/h2>\n<ul><li>\n\t\tAdd RemoteAddCommand<\/li>\n<li>\n\t\tAdd RemoteListCommand<\/li>\n<li>\n\t\tAdd RemoteRemoveCommand<\/li>\n<li>\n\t\tAdd option to allow empty commits to CommitCommand<\/li>\n<\/ul><h2>\n\tConfiguration<\/h2>\n<ul><li>\n<p>\t\t\tHonor some git-core fsck.* configuration settings\n\t<\/p><\/li>\n<\/ul><h2>\n\tJGit command line<\/h2>\n<ul><li>\n<p>RepoCommand: Add setRecordRemoteBranch option to record upstream branch<\/p>\n<\/li>\n<li>\n<p>git rev-parse: Add --verify option<\/p>\n<\/li>\n<li>\n<p>Add remote command to JGit command line<\/p>\n<\/li>\n<li>\n<p>Reset command support for the -- &lt;paths&gt; parameters<\/p>\n<\/li>\n<li>\n<p>Improved online help<\/p>\n<\/li>\n<\/ul><h2>\n\tTransport<\/h2>\n<ul><li>\n<p>Support more encryption algorithms for Amazon S3 storage of git repositories<\/p>\n<\/li>\n<li>\n<p>Support atomic push in JGit client<\/p>\n<\/li>\n<\/ul><h2>\n\tGit attribute support<\/h2>\n<ul><li>\n\t\tBasic support for .gitattribute handling<\/li>\n<\/ul><h2>\n\tSupport git-lfs extension<\/h2>\n<ul><li>\n<p>Add support for pre-push hooks<\/p>\n<\/li>\n<li>\n\t\tAdd support for smudge filters. If defined in .gitattributes call smudge filter during checkout.<\/li>\n<li>\n\t\tAdd support for clean filters. If defined in .gitattributes call clean filter during add to index.<\/li>\n<\/ul><p>These enhancements enable JGit and EGit to support the git-lfs extension [1] for versioning of large files<\/p>\n<p>[1] <a href=\"https:\/\/git-lfs.github.com\/\">https:\/\/git-lfs.github.com\/<\/a><\/p>\n<h2>\n\tPerformance Improvements<\/h2>\n<ul><li>\n\t\tImprove performance of DirCacheBuilder<\/li>\n<li>\n\t\tSpeed-up creation of DirCacheEntry<\/li>\n<li>\n\t\tSpeed-up garbage collection by improving generation of bitmap index<\/li>\n<li>\n\t\tSpeed-up delta-packing<\/li>\n<li>\n\t\tImprove bitmap index calculation to speed-up reachability calculations done during transport<\/li>\n<\/ul><h2>\n\tRelease Engineering and Build<\/h2>\n<ul><li>\n\t\tUse japicmp [1] instead of clirr to detect API changes since clirr doesn't support Java 8<\/li>\n<li>\n\t\tUse @Nullable annotations to aid detection of NPEs at design time<\/li>\n<li>\n\t\tAlternative <a href=\"https:\/\/buckbuild.com\/\">buck<\/a> build, much faster than Maven, can't build OSGi artefacts yet<\/li>\n<\/ul><p>[1] <a href=\"https:\/\/github.com\/siom79\/japicmp\">https:\/\/github.com\/siom79\/japicmp<\/a><\/p>\n","summary":"","value":"<h2>\r\n\tAPI<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdd RemoteAddCommand<\/li>\r\n\t<li>\r\n\t\tAdd RemoteListCommand<\/li>\r\n\t<li>\r\n\t\tAdd RemoteRemoveCommand<\/li>\r\n\t<li>\r\n\t\tAdd option to allow empty commits to CommitCommand<\/li>\r\n<\/ul>\r\n<h2>\r\n\tConfiguration<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tHonor some git-core fsck.* configuration settings<\/div>\r\n\t<\/li>\r\n<\/ul>\r\n<h2>\r\n\tJGit command line<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<p>RepoCommand: Add setRecordRemoteBranch option to record upstream branch<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p>git rev-parse: Add --verify option<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p>Add remote command to JGit command line<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p>Reset command support for the -- &lt;paths&gt; parameters<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p>Improved online help<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<h2>\r\n\tTransport<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<p>Support more encryption algorithms for Amazon S3 storage of git repositories<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p>Support atomic push in JGit client<\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<h2>\r\n\tGit attribute support<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tBasic support for .gitattribute handling<\/li>\r\n<\/ul>\r\n<h2>\r\n\tSupport git-lfs extension<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<p>Add support for pre-push hooks<\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\tAdd support for smudge filters.&nbsp;If defined in .gitattributes call smudge filter during checkout.<\/li>\r\n\t<li>\r\n\t\tAdd support for clean filters.&nbsp;If defined in .gitattributes call clean filter during add to index.<\/li>\r\n<\/ul>\r\n<p>These enhancements enable JGit and EGit to support the git-lfs extension [1] for versioning of large files<\/p>\r\n<p>[1]&nbsp;<a href=\"https:\/\/git-lfs.github.com\/\">https:\/\/git-lfs.github.com\/<\/a><\/p>\r\n<h2>\r\n\tPerformance Improvements<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tImprove performance of DirCacheBuilder<\/li>\r\n\t<li>\r\n\t\tSpeed-up creation of DirCacheEntry<\/li>\r\n\t<li>\r\n\t\tSpeed-up garbage collection by improving generation of bitmap index<\/li>\r\n\t<li>\r\n\t\tSpeed-up delta-packing<\/li>\r\n\t<li>\r\n\t\tImprove bitmap index calculation to speed-up reachability calculations done during transport<\/li>\r\n<\/ul>\r\n<h2>\r\n\tRelease Engineering and Build<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUse japicmp [1] instead of clirr to detect API changes since clirr doesn&#39;t support Java 8<\/li>\r\n\t<li>\r\n\t\tUse @Nullable annotations to aid detection of NPEs at design time<\/li>\r\n\t<li>\r\n\t\tAlternative <a href=\"https:\/\/buckbuild.com\/\">buck<\/a> build, much faster than Maven, can&#39;t build OSGi artefacts yet<\/li>\r\n<\/ul>\r\n<p>[1]&nbsp;<a href=\"https:\/\/github.com\/siom79\/japicmp\">https:\/\/github.com\/siom79\/japicmp<\/a><\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-01-20 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.2"}],"state":[{"value":"success"}],"title":"4.2 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.2-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.2","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-11-13 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This releases fixes the following bug:<\/p>\n<ul><li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved first last\">\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=478865\">478865<\/a> exactRef behaves differently in InMemoryRepository when HEAD is linked to a non-existent ref <\/li>\n<\/ul>","summary":"","value":"<p>This releases fixes the following bug:<\/p>\r\n<ul>\r\n\t<li class=\"bugzilla-record bugzilla-Normal bugzilla-fixed bugzilla-resolved first last\" style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=478865\" style=\"box-sizing: border-box; color: rgb(44, 34, 85); text-decoration: none; font-weight: bold; background-color: transparent;\">478865<\/a>&nbsp;exactRef behaves differently in InMemoryRepository when HEAD is linked to a non-existent ref&nbsp;<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.1.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.1.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-09-28 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h3>\n\tBasic Support for Push Certificates<\/h3>\n<p>\tPush certificates are used to verify the pusher's identity when a git server receives a signed pack<\/p>\n<ul><li>\n\t\tParsing of push certificates<\/li>\n<li>\n\t\tStorage of push certificates, they are stored in a special ref \"refs\/meta\/push-certs\". The filenames in the tree are ref names followed by the special suffix \"cert\", and the contents are the latest push cert affecting that ref.<\/li>\n<li>\n\t\tConfiguration for server-side signed push verification<\/li>\n<li>\n\t\tSupport for push certificates in BaseReceivePack and RefUpdate<\/li>\n<\/ul><h3>\n\tIgnore Handling<\/h3>\n<ul><li>\n\t\tAllow leading\/trailing spaces in ignore rules<\/li>\n<li>\n\t\tAllow leading literal '#' and '!' in ignore rules if they are escaped<\/li>\n<li>\n\t\tDon't trim trailing space if it is escaped with backslash<\/li>\n<\/ul><h3>\n\tOther Enhancements<\/h3>\n<ul><li>\n\t\tAdd setTargetBranch in RepoCommand.<\/li>\n<li>\n\t\tAdd API to remove repositories from RepositoryCache<\/li>\n<li>\n\t\tAdd new submodule layout to SubmoduleAddCommand<\/li>\n<li>\n\t\tHandle stale NFS file handles on packed-refs file<\/li>\n<li>\n\t\tAdd a grace period for packfiles during GC so that they are retained during GC until configured expiration age is reached<\/li>\n<\/ul><h3>\n\tPerformance Improvements<\/h3>\n<ul><li>\n\t\tUse java.io.File instead of NIO to check existence of loose objects in ObjectDirectory to speed up inserting of loose objects<\/li>\n<li>\n\t\tReduce memory consumption when creating bitmaps during writing pack files<\/li>\n<\/ul><h3>\n\tBuild and Release Engineering<\/h3>\n<ul><li>\n\t\tEnable annotation based NPE analysis in jgit<\/li>\n<li>\n\t\tUpdate Jetty to 9.2.13.v20150730<\/li>\n<li>\n\t\tUpdate org.apache.httpcomponents to 4.3<\/li>\n<\/ul><p>\t <\/p>\n<p>\t <\/p>\n","summary":"","value":"<h3>\r\n\tBasic Support for Push Certificates<\/h3>\r\n<div>\r\n\tPush certificates are used to verify the pusher&#39;s identity when a git server receives a signed pack<\/div>\r\n<ul>\r\n\t<li>\r\n\t\tParsing of push certificates<\/li>\r\n\t<li>\r\n\t\tStorage of push certificates, they are stored in a special ref &quot;refs\/meta\/push-certs&quot;.&nbsp;The filenames in the tree are ref names followed by the special suffix&nbsp;&quot;cert&quot;, and the contents are the latest push cert affecting that ref.<\/li>\r\n\t<li>\r\n\t\tConfiguration for server-side signed push verification<\/li>\r\n\t<li>\r\n\t\tSupport for push certificates in BaseReceivePack and RefUpdate<\/li>\r\n<\/ul>\r\n<h3>\r\n\tIgnore Handling<\/h3>\r\n<ul>\r\n\t<li>\r\n\t\tAllow leading\/trailing spaces in ignore rules<\/li>\r\n\t<li>\r\n\t\tAllow leading literal &#39;#&#39; and &#39;!&#39; in ignore rules if they are escaped<\/li>\r\n\t<li>\r\n\t\tDon&#39;t trim trailing space if it is escaped with backslash<\/li>\r\n<\/ul>\r\n<h3>\r\n\tOther Enhancements<\/h3>\r\n<ul>\r\n\t<li>\r\n\t\tAdd setTargetBranch in RepoCommand.<\/li>\r\n\t<li>\r\n\t\tAdd API to remove repositories from RepositoryCache<\/li>\r\n\t<li>\r\n\t\tAdd new submodule layout to SubmoduleAddCommand<\/li>\r\n\t<li>\r\n\t\tHandle stale NFS file handles on packed-refs file<\/li>\r\n\t<li>\r\n\t\tAdd a grace period for packfiles during GC so that they are retained during GC until configured expiration age is reached<\/li>\r\n<\/ul>\r\n<h3>\r\n\tPerformance Improvements<\/h3>\r\n<ul>\r\n\t<li>\r\n\t\tUse java.io.File instead of NIO to check existence of loose objects in ObjectDirectory to speed up inserting of loose objects<\/li>\r\n\t<li>\r\n\t\tReduce memory consumption when creating bitmaps during writing pack files<\/li>\r\n<\/ul>\r\n<h3>\r\n\tBuild and Release Engineering<\/h3>\r\n<ul>\r\n\t<li>\r\n\t\tEnable annotation based NPE analysis in jgit<\/li>\r\n\t<li>\r\n\t\tUpdate Jetty to 9.2.13.v20150730<\/li>\r\n\t<li>\r\n\t\tUpdate org.apache.httpcomponents to 4.3<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-09-16 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.1.0"}],"state":[{"value":"success"}],"title":"4.1.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.1.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.1.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-09-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=477148\">Bug 477148<\/a> - Contribute JSch 0.1.53 rather than 0.1.51 to Mars.1 <\/p>\n","summary":"","value":"<p>This release fixes&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=477148\">Bug 477148<\/a> - Contribute JSch 0.1.53 rather than 0.1.51 to Mars.1&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.0.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.0.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-09-14 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=463580\">bug 463580<\/a> and <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=470523\">bug 470523<\/a>.<\/p>\n","summary":"","value":"<p>This release fixes&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=463580\">bug&nbsp;463580<\/a>&nbsp;and&nbsp;<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=470523\">bug&nbsp;470523<\/a>.<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.0.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.0.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-06-24 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=468024\">bug 468024<\/a> which can cause data loss if a pack is pushed to a JGit based server and gc runs concurrently on the same repository.<\/p>\n","summary":"","value":"<p>This release fixes <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=468024\">bug 468024<\/a>&nbsp;which can cause data loss if a pack is pushed to a JGit based server and gc runs concurrently on the same repository.<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.0.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.0.1","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-06-24 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>3.4 was shipped with Luna and we release every 3 months.<br \/>\n\t4.0 will include the features from releases 3.5 - 3.7.<\/p>\n<p>API Cleanup<\/p>\n<ul><li>\n\t\tremove deprecated API<\/li>\n<li>\n\t\tdiscontinue support for Java 5 and Java 6<\/li>\n<\/ul><p>Breaking Changes<\/p>\n<ul><li>\n\t\tthere are a number of breaking changes pending since long time we can tackle in 4.0<\/li>\n<\/ul>","value":"<p>3.4 was shipped with Luna and we release every 3 months.<br \/>\r\n\t4.0 will include the features from releases 3.5 - 3.7.<\/p>\r\n<p>API Cleanup<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tremove deprecated API<\/li>\r\n\t<li>\r\n\t\tdiscontinue support for Java 5 and Java 6<\/li>\r\n<\/ul>\r\n<p>Breaking Changes<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tthere are a number of breaking changes pending since long time we can tackle in 4.0<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tUpdate to Java 7<\/h2>\n<ul><li>\n\t\tUpdate minimum required Java version from Java 5 to Java 7<\/li>\n<li>\n\t\tRemove bundles org.eclipse.jgit.console and org.eclipse.jgit.java7 which are no longer needed due to update to Java 7<\/li>\n<li>\n\t\tImplement AutoClosable and use it to ensure resource held by JGit get released when they are no longer needed<\/li>\n<\/ul><h2>\n\tAPI cleanup<\/h2>\n<ul><li>\n\t\tReplace release() methods by close() to support AutoClosable<\/li>\n<li>\n\t\tDelete some deprecated classes and methods, details are available in <a href=\"http:\/\/download.eclipse.org\/jgit\/site\/4.0.0-SNAPSHOT\/org.eclipse.jgit\/clirr-report.html\">Clirr API change report<\/a><\/li>\n<li>\n\t\tObjectReader: remove the walkAdvice API<\/li>\n<\/ul><h2>\n\tConfiguration<\/h2>\n<ul><li>\n\t\tRemove the gitprefix logic and rework detecting Git system config file<\/li>\n<li>\n\t\tAllow to manually set the path to the Git system config file<\/li>\n<li>\n\t\tAdd fsck.allowInvalidPersonIdent to accept invalid author\/committers<\/li>\n<\/ul><h2>\n\tProtocol<\/h2>\n<ul><li>\n\t\tAdd support for quiet capability to ReceivePack<\/li>\n<li>\n\t\tSupport agent= capability in wire protocol<\/li>\n<\/ul><h2>\n\tHooks<\/h2>\n<ul><li>\n\t\tSupport for the commit-msg hook<\/li>\n<\/ul><h2>\n\tMisc. Enhancements<\/h2>\n<ul><li>\n\t\tAllow ObjectWalk to be filtered by an arbitrary predicate<\/li>\n<li>\n\t\tUse ANY_DIFF filter in ResolveMerger for bare repositories<\/li>\n<li>\n\t\tObjectWalk: make setRetainBody(false) the default<\/li>\n<li>\n\t\tMake MyersDiff interruptible<\/li>\n<li>\n\t\tSupport --untracked-files in command line status command<\/li>\n<li>\n\t\tSupport \"--long\" option in DescribeCommand and command line describe command<\/li>\n<li>\n\t\tMake s3 domain dynamic to support different s3 regions in AmazonS3 transport<\/li>\n<li>\n\t\tAllow public access to PackIndex<\/li>\n<li>\n\t\tEnhance ArchiveCommand to allow passing options to underlying stream<\/li>\n<\/ul><h2>\n\tIntroduce logging<\/h2>\n<ul><li>\n\t\tUse slf4j API to enable logging in JGit<\/li>\n<li>\n\t\tUse log4j-slf4j to log from org.eclipse.jgit.pgm<\/li>\n<\/ul><h2>\n\tPerformance Improvements<\/h2>\n<ul><li>\n\t\tOptimize EolAwareOutputStream for bulk output<\/li>\n<li>\n\t\tBuffer TemporaryBuffer's overflow output stream used by ResolveMerger to improve performance<\/li>\n<li>\n\t\tRevWalk: Discard uninteresting commits unless RevSort.BOUNDARY<\/li>\n<\/ul><h2>\n\tFixes<\/h2>\n<ul><li>\n\t\tFix that exceptions in ReceivePack cause Invalid Channel 101 exceptions<\/li>\n<li>\n\t\tDon't invalidate pack file on InterruptedIOException<\/li>\n<li>\n\t\tFix RecursiveMerger in case of multiple, independent base commits<\/li>\n<li>\n\t\tFix many warnings<\/li>\n<li>\n\t\tFix several memory leaks<\/li>\n<\/ul><h2>\n\tBuild and release engineering<\/h2>\n<ul><li>\n\t\tUpdate build to use eclipse-jarsigner-plugin 1.1.2<\/li>\n<li>\n\t\tUpdate build to use Tycho 0.23.0<\/li>\n<li>\n\t\tUpdate all standard maven plugins to latest versions<\/li>\n<li>\n\t\tUpdate to Jetty 9.2.10<\/li>\n<li>\n\t\tUpdate to javax.servlet 3.1<\/li>\n<li>\n\t\tAdded more reports to Maven site<\/li>\n<\/ul><p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tUpdate to Java 7<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpdate minimum required Java version from Java 5 to Java 7<\/li>\r\n\t<li>\r\n\t\tRemove bundles org.eclipse.jgit.console and org.eclipse.jgit.java7&nbsp;which are no longer needed due to update to Java 7<\/li>\r\n\t<li>\r\n\t\tImplement AutoClosable and use it to ensure resource held by JGit get released when they are no longer needed<\/li>\r\n<\/ul>\r\n<h2>\r\n\tAPI cleanup<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tReplace release() methods by close() to support AutoClosable<\/li>\r\n\t<li>\r\n\t\tDelete some deprecated classes and methods, details are available in <a href=\"http:\/\/download.eclipse.org\/jgit\/site\/4.0.0-SNAPSHOT\/org.eclipse.jgit\/clirr-report.html\">Clirr API change report<\/a><\/li>\r\n\t<li>\r\n\t\tObjectReader: remove the walkAdvice API<\/li>\r\n<\/ul>\r\n<h2>\r\n\tConfiguration<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tRemove the gitprefix logic and rework detecting Git system config file<\/li>\r\n\t<li>\r\n\t\tAllow to manually set the path to the Git system config file<\/li>\r\n\t<li>\r\n\t\tAdd fsck.allowInvalidPersonIdent to accept invalid author\/committers<\/li>\r\n<\/ul>\r\n<h2>\r\n\tProtocol<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdd support for quiet capability to ReceivePack<\/li>\r\n\t<li>\r\n\t\tSupport agent= capability in wire protocol<\/li>\r\n<\/ul>\r\n<h2>\r\n\tHooks<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tSupport for the commit-msg hook<\/li>\r\n<\/ul>\r\n<h2>\r\n\tMisc. Enhancements<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAllow ObjectWalk to be filtered by an arbitrary predicate<\/li>\r\n\t<li>\r\n\t\tUse ANY_DIFF filter in ResolveMerger for bare repositories<\/li>\r\n\t<li>\r\n\t\tObjectWalk: make setRetainBody(false) the default<\/li>\r\n\t<li>\r\n\t\tMake MyersDiff interruptible<\/li>\r\n\t<li>\r\n\t\tSupport --untracked-files in command line status command<\/li>\r\n\t<li>\r\n\t\tSupport &quot;--long&quot; option in DescribeCommand and command line describe command<\/li>\r\n\t<li>\r\n\t\tMake s3 domain dynamic to support different s3 regions in AmazonS3 transport<\/li>\r\n\t<li>\r\n\t\tAllow public access to PackIndex<\/li>\r\n\t<li>\r\n\t\tEnhance ArchiveCommand to allow passing options to underlying stream<\/li>\r\n<\/ul>\r\n<h2>\r\n\tIntroduce logging<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUse slf4j API to enable logging in JGit<\/li>\r\n\t<li>\r\n\t\tUse log4j-slf4j to log from org.eclipse.jgit.pgm<\/li>\r\n<\/ul>\r\n<h2>\r\n\tPerformance Improvements<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tOptimize EolAwareOutputStream for bulk output<\/li>\r\n\t<li>\r\n\t\tBuffer TemporaryBuffer&#39;s overflow output stream used by ResolveMerger to improve performance<\/li>\r\n\t<li>\r\n\t\tRevWalk: Discard uninteresting commits unless RevSort.BOUNDARY<\/li>\r\n<\/ul>\r\n<h2>\r\n\tFixes<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tFix that exceptions in ReceivePack cause Invalid Channel 101 exceptions<\/li>\r\n\t<li>\r\n\t\tDon&#39;t invalidate pack file on InterruptedIOException<\/li>\r\n\t<li>\r\n\t\tFix RecursiveMerger in case of multiple, independent base commits<\/li>\r\n\t<li>\r\n\t\tFix many warnings<\/li>\r\n\t<li>\r\n\t\tFix several memory leaks<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and release engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpdate build to use eclipse-jarsigner-plugin 1.1.2<\/li>\r\n\t<li>\r\n\t\tUpdate build to use Tycho 0.23.0<\/li>\r\n\t<li>\r\n\t\tUpdate all standard maven plugins to latest versions<\/li>\r\n\t<li>\r\n\t\tUpdate to Jetty 9.2.10<\/li>\r\n\t<li>\r\n\t\tUpdate to javax.servlet 3.1<\/li>\r\n\t<li>\r\n\t\tAdded more reports to Maven site<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[],"environment":[{"format":"full_html","safe_value":"<p>Starting with 4.0 the minimum required Java version is updated from J2SE-1.5. to JavaSE-1.7<\/p>\n","value":"<p>Starting with 4.0 the minimum required Java version is updated from J2SE-1.5. to JavaSE-1.7<\/p>\r\n"}],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/4.0"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-06-17 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"4.0.0"}],"state":[{"value":"success"}],"title":"4.0.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/4.0.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"4.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/4.0.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-04-26 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=465509\">bug 465509<\/a> which caused massive performance problems in Gerrit.<\/p>\n","summary":"","value":"<p>This release fixes <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=465509\">bug 465509<\/a>&nbsp;which caused massive performance problems in Gerrit.<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.7.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.7.1","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-02-25 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tAdd basic support for .gitattributes<\/li>\n<li>\n<p>\t\t\tUse slf4j for logging\n\t<\/p><\/li>\n<li>\n\t\tIntroduce hook support into the FS implementations (on Posix and Cygwin)<\/li>\n<li>\n\t\tSupport for the pre-commit hook<\/li>\n<li>\n\t\tJGit command line: add option --orphan for checkout command<\/li>\n<li>\n<p>\t\t\tProvide more details in exceptions thrown when packfile is invalid\n\t<\/p><\/li>\n<\/ul><h2>\n\t<strong>Release Engineering<\/strong><\/h2>\n<ul><li>\n<p>\t\t\tUpdate build to Tycho 0.22.\n\t<\/p><\/li>\n<\/ul>","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdd basic support for .gitattributes<\/li>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tUse slf4j for logging<\/div>\r\n\t<\/li>\r\n\t<li>\r\n\t\tIntroduce hook support into the FS implementations (on Posix and Cygwin)<\/li>\r\n\t<li>\r\n\t\tSupport for the pre-commit hook<\/li>\r\n\t<li>\r\n\t\tJGit command line: add option --orphan for checkout command<\/li>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tProvide more details in exceptions thrown when packfile is invalid<\/div>\r\n\t<\/li>\r\n<\/ul>\r\n<h2>\r\n\t<strong>Release Engineering<\/strong><\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tUpdate build to Tycho 0.22.<\/div>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-02-25 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.7.0"}],"state":[{"value":"success"}],"title":"3.7.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.7.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.7.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.7.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-01-21 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following issues:<\/p>\n<p>\t<a href=\"https:\/\/code.google.com\/p\/gerrit\/issues\/detail?id=3094\">Gerrit bug 3094<\/a>: Don't remove pack from pack list for problems which could be transient<\/p>\n<p>\tLog reason for ignoring pack when IOException occurred<\/p>\n","summary":"","value":"<p><span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">This release fixes the following issues:<\/span><\/p>\r\n<div>\r\n\t<a href=\"https:\/\/code.google.com\/p\/gerrit\/issues\/detail?id=3094\">Gerrit bug 3094<\/a>: Don&#39;t remove pack from pack list for problems which could be transient<\/div>\r\n<div>\r\n\tLog reason for ignoring pack when IOException occurred<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.6.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.6.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-01-03 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes the following issues:<\/p>\n<p>\tTrim author\/committer name and email in commit header<\/p>\n<p>\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=449545\">Bug 449545<\/a> - Rename detection should canonicalize line endings<\/p>\n<p>\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=454672\">Bug 454672<\/a> - PathMatcher should respect \"assumeDirectory\" flag<\/p>\n","summary":"","value":"<p>This release fixes the following issues:<\/p>\r\n<div>\r\n\tTrim author\/committer name and email in commit header<\/div>\r\n<div>\r\n\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=449545\">Bug 449545<\/a> - Rename detection should canonicalize line endings<\/div>\r\n<div>\r\n\t<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=454672\">Bug 454672<\/a> - PathMatcher should respect &quot;assumeDirectory&quot; flag<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.6.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.6.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-12-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tIgnore rule parser was reimplemented to support ** wildcard patterns, negation rules and improve performance<\/li>\n<li>\n\t\tAdd \"aggressive\" option to GC<\/li>\n<li>\n\t\tGarbageCollectCommand now supports DfsRepository<\/li>\n<li>\n\t\tSupport for Submodule configuration submodule.&lt;name&gt;.ignore<\/li>\n<li>\n<p>\t\t\tSupport for new submodule repository layout (.git\/modules of the super project contains the submodule repositories)\n\t<\/p><\/li>\n<li>\n<p>\t\t\tInitCommand support for option \"--separate-git-dir\" to store .git meta data directory in a separate directory\n\t<\/p><\/li>\n<li>\n<p>\t\t\tCloneCommand support to store .git meta data directory in a separate directory\n\t<\/p><\/li>\n<li>\n\t\tPermission bits for \"executable\" attribute are now set according to the umask on Posix\/Java7<\/li>\n<li>\n\t\tBundleWriter now supports including HEAD in bundle<\/li>\n<li>\n\t\tNew config parameter core.trustfolderstat<\/li>\n<\/ul><h2>\n\tFeatures in JGit Command Line<\/h2>\n<ul><li>\n<p>\t\t\tAdd option --bare to clone command\n\t<\/p><\/li>\n<li>\n<p>\t\t\tAdd options --heads and --tags to ls-remote command\n\t<\/p><\/li>\n<\/ul><h2>\n\tPerformance Improvements<\/h2>\n<ul><li>\n\t\tReimplemented ignore rule parser to improve performance of ignore rule evaluation<\/li>\n<li>\n\t\tEnhance SubmoduleWalk with a fast check whether a repo contains submodules<\/li>\n<\/ul><p>\t <\/p>\n<h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tThe java7 feature is now included in org.eclipse.jgit.feature<\/li>\n<li>\n\t\tMaven site generation for jgit<\/li>\n<\/ul><h2>\n\tFix for vulnerability CVE-2014-9390<\/h2>\n<p>\t\tThe patches fixing <a href=\"http:\/\/article.gmane.org\/gmane.linux.kernel\/1853266\">CVE-2014-9390<\/a> released in JGit <a href=\"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.2\">3.4.2<\/a> and <a href=\"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.5.3\">3.5.3<\/a> are also included in 3.6.0.<\/p>\n<p>\t\t <\/p>\n<p>\t\t\t\tWe used to allow committing a path \".Git\/config\" with JGit &amp; EGit that is running on a case sensitive filesystem, but an attempt to check out such a path with Git that runs on a case insensitive filesystem would have clobbered \".git\/config\", which is definitely not what the user would have expected. JGit now prevents you from tracking a path with \".Git\" (in any case combination) as a path component.<\/p>\n<p>\t\t\t\t\t <\/p>\n<p>\t\t\t\t\tOn Windows, certain path components that are different from \".git\" are mapped to \".git\", e.g. \"git~1\/config\" is treated as if it were \".git\/config\".  HFS+ has a similar issue, where certain unicode codepoints are ignored, e.g. \".g\\u200cit\/config\" is treated as if it were \".git\/config\".  Pathnames with these potential issues are rejected on the affected systems.<\/p>\n<p>\t\t\t\t\t <\/p>\n<p>\t\t\t\t\t\tAs described in <a href=\"https:\/\/developer.atlassian.com\/blog\/2014\/12\/securing-your-git-server\/\">Securing your Git server<\/a> native git has been enhanced by configuration parameters allowing to configure a git server to check all objects it receives against problematic pathes. A server running e.g. on Linux can be configured to check also for pathes problematic on HFS+ or NTFS. This is also possible for JGit based Git servers. JGit understands the boolean config parameters receive.fsckobjects, fsck.safeForWindows and fsck.safeForMacOS. They match native git's receive.fsckobjects, core.protectNTFS, core.protectHFS.<\/p>\n<p>\t\t\t\t\t\t <\/p>\n<p>\t\t\t\t\t\t\t\t\t\tgit-core<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tJGit<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tdescription<\/p>\n<p>\t\t\t\t\t\t\t\t\t\treceive.fsckobjects<\/p>\n<p>\t\t\t\t\t\t\t\t\t\treceive.fsckobjects<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tenable checks when receiving objects<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tcore.protectNTFS<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tfsck.safeForWindows<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tcheck pathes problematic on NTFS<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tcore.protectHFS<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tfsck.safeForMacOS<\/p>\n<p>\t\t\t\t\t\t\t\t\t\tcheck pathes problematic on HFS+<\/p>\n<p>\t\t\t\t\t\t.<\/p>\n<p>\t\t\t\t\t\tEnabling receive.fsckObjects makes JGit check the integrity of objects before a push is accepted, which is a pre-requisite for the other flags. The fsck.safeForMacOS and fsck.safeForWindows flags prevent the Mac OS X and Windows vulnerabilities described above, respectively. Both default to true on their respective systems but will need to be enabled specifically on other platforms. Since clients could be using a different operating system to your server you should enable both on JGit based servers.<\/p>\n<p>\t\t\t\t\t <\/p>\n<p>\t\t\t\t\tA big \"thanks!\" for bringing this issue to us goes to our friends in the Mercurial land, namely, Matt Mackall and Augie Fackler.<\/p>\n<p>\t\t\t\t\t <\/p>\n<p> <\/p>\n","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tIgnore rule parser was reimplemented to support ** wildcard patterns, negation rules and improve performance<\/li>\r\n\t<li>\r\n\t\tAdd &quot;aggressive&quot; option to GC<\/li>\r\n\t<li>\r\n\t\tGarbageCollectCommand now supports DfsRepository<\/li>\r\n\t<li>\r\n\t\tSupport for Submodule configuration submodule.&lt;name&gt;.ignore<\/li>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tSupport for new submodule repository layout (.git\/modules of the super project contains the submodule repositories)<\/div>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tInitCommand support for option &quot;--separate-git-dir&quot; to store .git meta data directory in a separate directory<\/div>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tCloneCommand support to store .git meta data directory in a separate directory<\/div>\r\n\t<\/li>\r\n\t<li>\r\n\t\tPermission bits for &quot;executable&quot; attribute are now set according to the umask on Posix\/Java7<\/li>\r\n\t<li>\r\n\t\tBundleWriter now supports including HEAD in bundle<\/li>\r\n\t<li>\r\n\t\tNew config parameter core.trustfolderstat<\/li>\r\n<\/ul>\r\n<h2>\r\n\tFeatures in JGit Command Line<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tAdd option --bare to clone command<\/div>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<div>\r\n\t\t\tAdd options --heads and --tags to ls-remote command<\/div>\r\n\t<\/li>\r\n<\/ul>\r\n<h2>\r\n\tPerformance Improvements<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tReimplemented ignore rule parser to improve performance of ignore rule evaluation<\/li>\r\n\t<li>\r\n\t\tEnhance SubmoduleWalk with a fast check whether a repo contains submodules<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tThe java7 feature is now included in org.eclipse.jgit.feature<\/li>\r\n\t<li>\r\n\t\tMaven site generation for jgit<\/li>\r\n<\/ul>\r\n<h2>\r\n\tFix for vulnerability CVE-2014-9390<\/h2>\r\n<div>\r\n\t<div>\r\n\t\tThe patches fixing <a href=\"http:\/\/article.gmane.org\/gmane.linux.kernel\/1853266\">CVE-2014-9390<\/a> released in JGit <a href=\"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.2\">3.4.2<\/a> and <a href=\"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.5.3\">3.5.3<\/a>&nbsp;are also included in 3.6.0.<\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n\t<div>\r\n\t\t<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t\t\t<div>\r\n\t\t\t\tWe used to allow committing a path &quot;.Git\/config&quot; with JGit &amp; EGit that is running on a case sensitive filesystem, but an attempt to check out such a path with Git that runs on a case insensitive filesystem would have clobbered &quot;.git\/config&quot;, which is definitely not what the user would have expected. JGit now prevents you from tracking a path with &quot;.Git&quot; (in any case combination) as a path component.<\/div>\r\n\t\t\t<div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\t&nbsp;<\/div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\tOn Windows, certain path components that are different from &quot;.git&quot; are mapped to &quot;.git&quot;, e.g. &quot;git~1\/config&quot; is treated as if it were &quot;.git\/config&quot;. &nbsp;HFS+ has a similar issue, where certain unicode codepoints are ignored, e.g. &quot;.g\\u200cit\/config&quot; is treated as if it were &quot;.git\/config&quot;. &nbsp;Pathnames with these potential issues are rejected on the affected systems.<\/div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\t&nbsp;<\/div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\t<div>\r\n\t\t\t\t\t\tAs described in&nbsp;<a href=\"https:\/\/developer.atlassian.com\/blog\/2014\/12\/securing-your-git-server\/\">Securing your Git server<\/a>&nbsp;native git has been enhanced by configuration parameters allowing to configure a git server to check all objects it receives against problematic pathes. A server running e.g. on Linux can be configured to check also for pathes problematic on HFS+ or NTFS. This is also possible for JGit based Git servers. JGit understands the boolean config parameters&nbsp;<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects, fsck.safeForWindows&nbsp;and fsck.safeForMacOS. They match native git&#39;s receive.fsckobjects, core.protectNTFS, core.protectHFS.<\/span><\/div>\r\n\t\t\t\t\t<div>\r\n\t\t\t\t\t\t&nbsp;<\/div>\r\n\t\t\t\t\t<div>\r\n\t\t\t\t\t\t<table border=\"1\" cellpadding=\"1\" cellspacing=\"1\" style=\"width: 500px;\">\r\n\t\t\t\t\t\t\t<thead>\r\n\t\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; line-height: 20px;\">git-core<\/span><\/th>\r\n\t\t\t\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t\t\t\tJGit<\/th>\r\n\t\t\t\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t\t\t\tdescription<\/th>\r\n\t\t\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t\t\t<\/thead>\r\n\t\t\t\t\t\t\t<tbody>\r\n\t\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects<\/span><\/td>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects<\/span><\/td>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\"><span style=\"color: rgb(51, 51, 51); line-height: 20px;\">enable checks when receiving objects<\/span><\/span><\/td>\r\n\t\t\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">core.protectNTFS<\/span><\/td>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">fsck.safeForWindows<\/span><\/td>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">check pathes problematic on NTFS<\/span><\/td>\r\n\t\t\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">core.protectHFS<\/span><\/td>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">fsck.safeForMacOS<\/span><\/td>\r\n\t\t\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\"><span style=\"color: rgb(51, 51, 51); line-height: 20px;\">check pathes problematic on HFS+<\/span><\/span><\/td>\r\n\t\t\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t\t\t<\/tbody>\r\n\t\t\t\t\t\t<\/table>\r\n\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">.<\/span><\/div>\r\n\t\t\t\t\t<div>\r\n\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">Enabling receive.fsckObjects&nbsp;makes JGit check the integrity of objects before a push is accepted, which is a pre-requisite for the other flags. The fsck.safeForMacOS and fsck.safeForWindows&nbsp;flags<\/span>&nbsp;prevent the Mac OS X and Windows vulnerabilities described above, respectively. Both default to true on their respective systems but will need to be enabled specifically on other platforms. Since clients could be using a different operating system to your server you should enable both on JGit based servers.<\/div>\r\n\t\t\t\t<\/div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\t&nbsp;<\/div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\tA big &quot;thanks!&quot; for bringing this issue to us goes to our friends in the Mercurial land, namely, Matt Mackall and Augie Fackler.<\/div>\r\n\t\t\t\t<div>\r\n\t\t\t\t\t&nbsp;<\/div>\r\n\t\t\t<\/div>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-12-17 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.6.0"}],"state":[{"value":"success"}],"title":"3.6.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.6.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.6.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.6.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-12-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\t\t\tFix for vulnerability CVE-2014-9390<\/h2>\n<p>\t\tThis is a security-fix for <a href=\"http:\/\/article.gmane.org\/gmane.linux.kernel\/1853266\">CVE-2014-9390<\/a>, which affects users on Windows and Mac OS X but not typical UNIX users.<\/p>\n<p>\t\tCVE entry: <a href=\"http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390\">http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390<\/a><\/p>\n<p>\t\t <\/p>\n<p>\t\tWe used to allow committing a path \".Git\/config\" with JGit &amp; EGit that is running on a case sensitive filesystem, but an attempt to check out such a path with Git that runs on a case insensitive filesystem would have clobbered \".git\/config\", which is definitely not what the user would have expected. JGit now prevents you from tracking a path with \".Git\" (in any case combination) as a path component.<\/p>\n<p>\t\t\t <\/p>\n<p>\t\t\tOn Windows, certain path components that are different from \".git\" are mapped to \".git\", e.g. \"git~1\/config\" is treated as if it were \".git\/config\".  HFS+ has a similar issue, where certain unicode codepoints are ignored, e.g. \".g\\u200cit\/config\" is treated as if it were \".git\/config\".  Pathnames with these potential issues are rejected on the affected systems.<\/p>\n<p>\t\t\t <\/p>\n<p>\t\t\t\tAs described in <a href=\"https:\/\/developer.atlassian.com\/blog\/2014\/12\/securing-your-git-server\/\">Securing your Git server<\/a> native git has been enhanced by configuration parameters allowing to configure a git server to check all objects it receives against problematic pathes. A server running e.g. on Linux can be configured to check also for pathes problematic on HFS+ or NTFS. This is also possible for JGit based Git servers. JGit understands the boolean config parameters receive.fsckobjects, fsck.safeForWindows and fsck.safeForMacOS. They match native git's receive.fsckobjects, core.protectNTFS, core.protectHFS.<\/p>\n<p>\t\t\t\t <\/p>\n<p>\t\t\t\t\t\t\t\tgit-core<\/p>\n<p>\t\t\t\t\t\t\t\tJGit<\/p>\n<p>\t\t\t\t\t\t\t\tdescription<\/p>\n<p>\t\t\t\t\t\t\t\treceive.fsckobjects<\/p>\n<p>\t\t\t\t\t\t\t\treceive.fsckobjects<\/p>\n<p>\t\t\t\t\t\t\t\tenable checks when receiving objects<\/p>\n<p>\t\t\t\t\t\t\t\tcore.protectNTFS<\/p>\n<p>\t\t\t\t\t\t\t\tfsck.safeForWindows<\/p>\n<p>\t\t\t\t\t\t\t\tcheck pathes problematic on NTFS<\/p>\n<p>\t\t\t\t\t\t\t\tcore.protectHFS<\/p>\n<p>\t\t\t\t\t\t\t\tfsck.safeForMacOS<\/p>\n<p>\t\t\t\t\t\t\t\tcheck pathes problematic on HFS+<\/p>\n<p>\t\t\t\t.<\/p>\n<p>\t\t\t\tEnabling receive.fsckObjects makes JGit check the integrity of objects before a push is accepted, which is a pre-requisite for the other flags. The fsck.safeForMacOS and fsck.safeForWindows flags prevent the Mac OS X and Windows vulnerabilities described above, respectively. Both default to true on their respective systems but will need to be enabled specifically on other platforms. Since clients could be using a different operating system to your server you should enable both on JGit based servers.<\/p>\n<p>\t\t\t <\/p>\n<p>\t\t\tA big \"thanks!\" for bringing this issue to us goes to our friends in the Mercurial land, namely, Matt Mackall and Augie Fackler.<\/p>\n<p>\t\t\t <\/p>\n<p> <\/p>\n","summary":"","value":"<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t<div>\r\n\t\t<h2>\r\n\t\t\tFix for vulnerability CVE-2014-9390<\/h2>\r\n\t<\/div>\r\n\t<div>\r\n\t\tThis is a security-fix for&nbsp;<a href=\"http:\/\/article.gmane.org\/gmane.linux.kernel\/1853266\">CVE-2014-9390<\/a>, which affects users on Windows and Mac OS X but not typical UNIX users.<\/div>\r\n\t<div>\r\n\t\tCVE entry:&nbsp;<a href=\"http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390\">http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390<\/a><\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n\t<div>\r\n\t\tWe used to allow committing a path &quot;.Git\/config&quot; with JGit &amp; EGit that is running on a case sensitive filesystem, but an attempt to check out such a path with Git that runs on a case insensitive filesystem would have clobbered &quot;.git\/config&quot;, which is definitely not what the user would have expected. JGit now prevents you from tracking a path with &quot;.Git&quot; (in any case combination) as a path component.<\/div>\r\n\t<div>\r\n\t\t<div>\r\n\t\t\t&nbsp;<\/div>\r\n\t\t<div>\r\n\t\t\tOn Windows, certain path components that are different from &quot;.git&quot; are mapped to &quot;.git&quot;, e.g. &quot;git~1\/config&quot; is treated as if it were &quot;.git\/config&quot;. &nbsp;HFS+ has a similar issue, where certain unicode codepoints are ignored, e.g. &quot;.g\\u200cit\/config&quot; is treated as if it were &quot;.git\/config&quot;. &nbsp;Pathnames with these potential issues are rejected on the affected systems.<\/div>\r\n\t\t<div>\r\n\t\t\t&nbsp;<\/div>\r\n\t\t<div>\r\n\t\t\t<div>\r\n\t\t\t\tAs described in&nbsp;<a href=\"https:\/\/developer.atlassian.com\/blog\/2014\/12\/securing-your-git-server\/\">Securing your Git server<\/a>&nbsp;native git has been enhanced by configuration parameters allowing to configure a git server to check all objects it receives against problematic pathes. A server running e.g. on Linux can be configured to check also for pathes problematic on HFS+ or NTFS. This is also possible for JGit based Git servers. JGit understands the boolean config parameters&nbsp;<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects, fsck.safeForWindows&nbsp;and fsck.safeForMacOS. They match native git&#39;s receive.fsckobjects, core.protectNTFS, core.protectHFS.<\/span><\/div>\r\n\t\t\t<div>\r\n\t\t\t\t&nbsp;<\/div>\r\n\t\t\t<div>\r\n\t\t\t\t<table border=\"1\" cellpadding=\"1\" cellspacing=\"1\" style=\"width: 500px;\">\r\n\t\t\t\t\t<thead>\r\n\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t\t<span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; line-height: 20px;\">git-core<\/span><\/th>\r\n\t\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t\tJGit<\/th>\r\n\t\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t\tdescription<\/th>\r\n\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t<\/thead>\r\n\t\t\t\t\t<tbody>\r\n\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects<\/span><\/td>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects<\/span><\/td>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\"><span style=\"color: rgb(51, 51, 51); line-height: 20px;\">enable checks when receiving objects<\/span><\/span><\/td>\r\n\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">core.protectNTFS<\/span><\/td>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">fsck.safeForWindows<\/span><\/td>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">check pathes problematic on NTFS<\/span><\/td>\r\n\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">core.protectHFS<\/span><\/td>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">fsck.safeForMacOS<\/span><\/td>\r\n\t\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\"><span style=\"color: rgb(51, 51, 51); line-height: 20px;\">check pathes problematic on HFS+<\/span><\/span><\/td>\r\n\t\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t<\/tbody>\r\n\t\t\t\t<\/table>\r\n\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">.<\/span><\/div>\r\n\t\t\t<div>\r\n\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">Enabling receive.fsckObjects&nbsp;makes JGit check the integrity of objects before a push is accepted, which is a pre-requisite for the other flags. The fsck.safeForMacOS and fsck.safeForWindows&nbsp;flags<\/span>&nbsp;prevent the Mac OS X and Windows vulnerabilities described above, respectively. Both default to true on their respective systems but will need to be enabled specifically on other platforms. Since clients could be using a different operating system to your server you should enable both on JGit based servers.<\/div>\r\n\t\t<\/div>\r\n\t\t<div>\r\n\t\t\t&nbsp;<\/div>\r\n\t\t<div>\r\n\t\t\tA big &quot;thanks!&quot; for bringing this issue to us goes to our friends in the Mercurial land, namely, Matt Mackall and Augie Fackler.<\/div>\r\n\t\t<div>\r\n\t\t\t&nbsp;<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.5.3","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.5.3","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-12-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\t\tFix for vulnerability CVE-2014-9390<\/h2>\n<p>\tThis is a security-fix for <a href=\"http:\/\/article.gmane.org\/gmane.linux.kernel\/1853266\">CVE-2014-9390<\/a>, which affects users on Windows and Mac OS X but not typical UNIX users.<\/p>\n<p>\tCVE entry: <a href=\"http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390\">http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390<\/a><\/p>\n<p>\t <\/p>\n<p>\tWe used to allow committing a path \".Git\/config\" with JGit &amp; EGit that is running on a case sensitive filesystem, but an attempt to check out such a path with Git that runs on a case insensitive filesystem would have clobbered \".git\/config\", which is definitely not what the user would have expected. JGit now prevents you from tracking a path with \".Git\" (in any case combination) as a path component.<\/p>\n<p>\t\t <\/p>\n<p>\t\tOn Windows, certain path components that are different from \".git\" are mapped to \".git\", e.g. \"git~1\/config\" is treated as if it were \".git\/config\".  HFS+ has a similar issue, where certain unicode codepoints are ignored, e.g. \".g\\u200cit\/config\" is treated as if it were \".git\/config\".  Pathnames with these potential issues are rejected on the affected systems.<\/p>\n<p>\t\t <\/p>\n<p>\t\t\tAs described in <a href=\"https:\/\/developer.atlassian.com\/blog\/2014\/12\/securing-your-git-server\/\">Securing your Git server<\/a> native git has been enhanced by configuration parameters allowing to configure a git server to check all objects it receives against problematic pathes. A server running e.g. on Linux can be configured to check also for pathes problematic on HFS+ or NTFS. This is also possible for JGit based Git servers. JGit understands the boolean config parameters receive.fsckobjects, fsck.safeForWindows and fsck.safeForMacOS. They match native git's receive.fsckobjects, core.protectNTFS, core.protectHFS.<\/p>\n<p>\t\t\t <\/p>\n<p>\t\t\t\t\t\t\tgit-core<\/p>\n<p>\t\t\t\t\t\t\tJGit<\/p>\n<p>\t\t\t\t\t\t\tdescription<\/p>\n<p>\t\t\t\t\t\t\treceive.fsckobjects<\/p>\n<p>\t\t\t\t\t\t\treceive.fsckobjects<\/p>\n<p>\t\t\t\t\t\t\tenable checks when receiving objects<\/p>\n<p>\t\t\t\t\t\t\tcore.protectNTFS<\/p>\n<p>\t\t\t\t\t\t\tfsck.safeForWindows<\/p>\n<p>\t\t\t\t\t\t\tcheck pathes problematic on NTFS<\/p>\n<p>\t\t\t\t\t\t\tcore.protectHFS<\/p>\n<p>\t\t\t\t\t\t\tfsck.safeForMacOS<\/p>\n<p>\t\t\t\t\t\t\tcheck pathes problematic on HFS+<\/p>\n<p>\t\t\t.<\/p>\n<p>\t\t\tEnabling receive.fsckObjects makes JGit check the integrity of objects before a push is accepted, which is a pre-requisite for the other flags. The fsck.safeForMacOS and fsck.safeForWindows flags prevent the Mac OS X and Windows vulnerabilities described above, respectively. Both default to true on their respective systems but will need to be enabled specifically on other platforms. Since clients could be using a different operating system to your server you should enable both on JGit based servers.<\/p>\n<p>\t\t <\/p>\n<p>\t\tA big \"thanks!\" for bringing this issue to us goes to our friends in the Mercurial land, namely, Matt Mackall and Augie Fackler.<\/p>\n<p>\t\t <\/p>\n<p> <\/p>\n","summary":"","value":"<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t<h2>\r\n\t\tFix for vulnerability CVE-2014-9390<\/h2>\r\n<\/div>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\tThis is a security-fix for&nbsp;<a href=\"http:\/\/article.gmane.org\/gmane.linux.kernel\/1853266\">CVE-2014-9390<\/a>, which affects users on Windows and Mac OS X but not typical UNIX users.<\/div>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\tCVE entry:&nbsp;<a href=\"http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390\">http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name=CVE-2014-9390<\/a><\/div>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t&nbsp;<\/div>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\tWe used to allow committing a path &quot;.Git\/config&quot; with JGit &amp; EGit that is running on a case sensitive filesystem, but an attempt to check out such a path with Git that runs on a case insensitive filesystem would have clobbered &quot;.git\/config&quot;, which is definitely not what the user would have expected. JGit now prevents you from tracking a path with &quot;.Git&quot; (in any case combination) as a path component.<\/div>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n\t<div>\r\n\t\tOn Windows, certain path components that are different from &quot;.git&quot; are mapped to &quot;.git&quot;, e.g. &quot;git~1\/config&quot; is treated as if it were &quot;.git\/config&quot;. &nbsp;HFS+ has a similar issue, where certain unicode codepoints are ignored, e.g. &quot;.g\\u200cit\/config&quot; is treated as if it were &quot;.git\/config&quot;. &nbsp;Pathnames with these potential issues are rejected on the affected systems.<\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n\t<div>\r\n\t\t<div>\r\n\t\t\tAs described in&nbsp;<a href=\"https:\/\/developer.atlassian.com\/blog\/2014\/12\/securing-your-git-server\/\">Securing your Git server<\/a>&nbsp;native git has been enhanced by configuration parameters allowing to configure a git server to check all objects it receives against problematic pathes. A server running e.g. on Linux can be configured to check also for pathes problematic on HFS+ or NTFS. This is also possible for JGit based Git servers. JGit understands the boolean config parameters&nbsp;<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects, fsck.safeForWindows&nbsp;and fsck.safeForMacOS. They match native git&#39;s receive.fsckobjects, core.protectNTFS, core.protectHFS.<\/span><\/div>\r\n\t\t<div>\r\n\t\t\t&nbsp;<\/div>\r\n\t\t<div>\r\n\t\t\t<table border=\"1\" cellpadding=\"1\" cellspacing=\"1\" style=\"width: 500px;\">\r\n\t\t\t\t<thead>\r\n\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\t<span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; line-height: 20px;\">git-core<\/span><\/th>\r\n\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\tJGit<\/th>\r\n\t\t\t\t\t\t<th scope=\"col\">\r\n\t\t\t\t\t\t\tdescription<\/th>\r\n\t\t\t\t\t<\/tr>\r\n\t\t\t\t<\/thead>\r\n\t\t\t\t<tbody>\r\n\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects<\/span><\/td>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">receive.fsckobjects<\/span><\/td>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\"><span style=\"color: rgb(51, 51, 51); line-height: 20px;\">enable checks when receiving objects<\/span><\/span><\/td>\r\n\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">core.protectNTFS<\/span><\/td>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">fsck.safeForWindows<\/span><\/td>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">check pathes problematic on NTFS<\/span><\/td>\r\n\t\t\t\t\t<\/tr>\r\n\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">core.protectHFS<\/span><\/td>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">fsck.safeForMacOS<\/span><\/td>\r\n\t\t\t\t\t\t<td>\r\n\t\t\t\t\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\"><span style=\"color: rgb(51, 51, 51); line-height: 20px;\">check pathes problematic on HFS+<\/span><\/span><\/td>\r\n\t\t\t\t\t<\/tr>\r\n\t\t\t\t<\/tbody>\r\n\t\t\t<\/table>\r\n\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">.<\/span><\/div>\r\n\t\t<div>\r\n\t\t\t<span style=\"font-family: arial, helvetica, sans-serif;\">Enabling receive.fsckObjects&nbsp;makes JGit check the integrity of objects before a push is accepted, which is a pre-requisite for the other flags. The fsck.safeForMacOS and fsck.safeForWindows&nbsp;flags<\/span>&nbsp;prevent the Mac OS X and Windows vulnerabilities described above, respectively. Both default to true on their respective systems but will need to be enabled specifically on other platforms. Since clients could be using a different operating system to your server you should enable both on JGit based servers.<\/div>\r\n\t<\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n\t<div>\r\n\t\tA big &quot;thanks!&quot; for bringing this issue to us goes to our friends in the Mercurial land, namely, Matt Mackall and Augie Fackler.<\/div>\r\n\t<div>\r\n\t\t&nbsp;<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.4.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-11-12 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>This release fixes<\/p>\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=450170\">Bug 450170<\/a> - Don't use SSL anymore to avoid POODLE attack<\/p>\n","summary":"","value":"<p>This release fixes<\/p>\r\n<p><a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=450170\">Bug 450170<\/a> - Don&#39;t use SSL anymore to avoid POODLE attack<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.5.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.5.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-10-14 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>maintenance release containing the following bug fixes:<\/p>\n<p>\t88b25a5 - 2014-10-10, Christian Halstrick : When marking commits as uninteresting don't care if the tree exists (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=445744\">Bug: 445744<\/a>)<\/p>\n<p>\t668acc6 - 2014-10-07, Matthias Sohn : Only hide gitdir if the repository isn't bare (<a href=\"https:\/\/dev.eclipse.org\/mhonarc\/lists\/jgit-dev\/msg02675.html\">reported on jgit-dev<\/a>)<\/p>\n","summary":"","value":"<p>maintenance release containing the following bug fixes:<\/p>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t88b25a5 - 2014-10-10, Christian Halstrick : When marking commits as uninteresting don&#39;t care if the tree exists (<a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=445744\">Bug: 445744<\/a>)<\/div>\r\n<div style=\"font-family: arial, sans-serif; font-size: 13px;\">\r\n\t668acc6 - 2014-10-07, Matthias Sohn : Only hide gitdir if the repository isn&#39;t bare (<a href=\"https:\/\/dev.eclipse.org\/mhonarc\/lists\/jgit-dev\/msg02675.html\">reported on jgit-dev<\/a>)<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.5.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.5.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[{"format":"full_html","safe_value":"<p>None known.<\/p>\n","value":"<p><span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">None known.<\/span><\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<h3>\n\tCommunication Channels<\/h3>\n<ul><li>\n\t\tEclipse Bugzilla<\/li>\n<li>\n\t\tActive EGit forum @ eclipse.org is also used for JGit questions<\/li>\n<li>\n\t\tJGit Mailing List cSmSDFGV27dWafJS@eTt28f16hVTiHKpb<\/li>\n<\/ul><h3>\n\tContributors<\/h3>\n<p>\tThe following 22 developers worked on this release of JGit:<\/p>\n<p>\t <\/p>\n<p>\tAlexey Kuznetsov, Andrey Loskutov, Anton Bannykh, Axel Richard, Christian Halstrick, Dani Megert, Dave Borowitz, Hugo Arès, <\/p>\n<p>\tKevin Sawicki, Konrad Kügler, Laurent Goubet, Maik Schreiber, Marc Strapetz, Matthias Sohn, Roberto Tyley, Robin Rosenberg,<\/p>\n<p>\tRobin Stocker, Rüdiger Herrmann, Saša Živkov, Shawn Pearce, Yi EungJun, Yuxuan 'fishy' Wang<\/p>\n<p>\t <\/p>\n","value":"<h3 style=\"box-sizing: border-box; font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-weight: 300; line-height: 20px; color: rgb(51, 51, 51); margin: 0px 0px 10px; font-size: 14px;\">\r\n\tCommunication Channels<\/h3>\r\n<ul style=\"box-sizing: border-box; margin-top: 0px; margin-bottom: 10px; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">\r\n\t<li style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\tEclipse Bugzilla<\/li>\r\n\t<li style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\tActive EGit forum @ eclipse.org is also used for JGit questions<\/li>\r\n\t<li style=\"box-sizing: border-box; padding-bottom: 7px;\">\r\n\t\tJGit Mailing List cSmSDFGV27dWafJS@eTt28f16hVTiHKpb<\/li>\r\n<\/ul>\r\n<h3 style=\"box-sizing: border-box; font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-weight: 300; line-height: 1.1; color: rgb(51, 51, 51); margin-top: 20px; margin-bottom: 10px; font-size: 24px; padding-bottom: 7px;\">\r\n\tContributors<\/h3>\r\n<div>\r\n\tThe following 22 developers worked on this release of JGit:<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n<div>\r\n\tAlexey Kuznetsov, Andrey Loskutov, Anton Bannykh, Axel Richard, Christian Halstrick, Dani Megert, Dave Borowitz, Hugo Ar&egrave;s,&nbsp;<\/div>\r\n<div>\r\n\tKevin Sawicki, Konrad K&uuml;gler, Laurent Goubet, Maik Schreiber, Marc Strapetz, Matthias Sohn, Roberto Tyley, Robin Rosenberg,<\/div>\r\n<div>\r\n\tRobin Stocker, R&uuml;diger Herrmann, Sa&scaron;a Živkov, Shawn Pearce, Yi EungJun, Yuxuan &#39;fishy&#39; Wang<\/div>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-09-24 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<h2>\n\tFeatures<\/h2>\n<ul><li>\n\t\tAdded parser and credentials provider for .netrc files<\/li>\n<li>\n\t\tRebaseCommand support for option --preserve-merges<\/li>\n<li>\n\t\tCommitCommand support for committing merges during rebase<\/li>\n<li>\n\t\tCherryPickCommand support for option --no-commit<\/li>\n<li>\n\t\tPull with rebase now supports option --preserve-merges<\/li>\n<li>\n\t\tEnhance BranchConfig API to expose branch.* options<\/li>\n<li>\n\t\tRepoCommand\n<ul><li>\n\t\t\t\tAllow projects without path attribute in manifest<\/li>\n<li>\n\t\t\t\tHandle repo manifest file without default remote<\/li>\n<li>\n\t\t\t\tSupport remote aliases in repo manifest<\/li>\n<li>\n\t\t\t\tSupport non-default remotes in project tag<\/li>\n<li>\n\t\t\t\tAdd support to &lt;include&gt; tag in repo manifest xml<\/li>\n<\/ul><\/li>\n<\/ul><h2>\n\tFeatures in JGit Command Line<\/h2>\n<ul><li>\n\t\tMerge command support for option -m<\/li>\n<\/ul><h2>\n\tPerformance Improvements<\/h2>\n<ul><li>\n\t\tProcess most in-core merges without local temp files<\/li>\n<li>\n\t\tSmall performance optimization for ignore rules matcher<\/li>\n<\/ul><h2>\n\tBuild and Release Engineering<\/h2>\n<ul><li>\n\t\tUpdated Maven plugins used in build to latest versions<\/li>\n<li>\n\t\tEnable NLS \/ TranslationBundle to be used in OSGi<\/li>\n<\/ul><p>\t <\/p>\n","summary":"","value":"<h2>\r\n\tFeatures<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tAdded parser and credentials provider for .netrc files<\/li>\r\n\t<li>\r\n\t\tRebaseCommand support for option --preserve-merges<\/li>\r\n\t<li>\r\n\t\tCommitCommand support for committing merges during rebase<\/li>\r\n\t<li>\r\n\t\tCherryPickCommand support for option --no-commit<\/li>\r\n\t<li>\r\n\t\tPull with rebase now supports option --preserve-merges<\/li>\r\n\t<li>\r\n\t\tEnhance BranchConfig API to expose branch.* options<\/li>\r\n\t<li>\r\n\t\tRepoCommand\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tAllow projects without path attribute in manifest<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tHandle repo manifest file without default remote<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport remote aliases in repo manifest<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport non-default remotes in project tag<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tAdd support to &lt;include&gt; tag in repo manifest xml<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n<h2>\r\n\tFeatures in JGit Command Line<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tMerge command support for option -m<\/li>\r\n<\/ul>\r\n<h2>\r\n\tPerformance Improvements<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tProcess most in-core merges without local temp files<\/li>\r\n\t<li>\r\n\t\tSmall performance optimization for ignore rules matcher<\/li>\r\n<\/ul>\r\n<h2>\r\n\tBuild and Release Engineering<\/h2>\r\n<ul>\r\n\t<li>\r\n\t\tUpdated Maven plugins used in build to latest versions<\/li>\r\n\t<li>\r\n\t\tEnable NLS \/ TranslationBundle to be used in OSGi<\/li>\r\n<\/ul>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>No features will be dropped for this release.<\/p>\n<p>\t <\/p>\n","value":"<p style=\"box-sizing: border-box; margin: 0px 0px 10px; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\"><span style=\"box-sizing: border-box;\">No features will be dropped for this release.<\/span><\/p>\r\n<div>\r\n\t&nbsp;<\/div>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>API documentation (JavaDoc) is provided.<\/p>\n","value":"<p>API documentation (JavaDoc) is provided.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/3.5"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-09-24 00:00:00"}],"links":[],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.5.0"}],"state":[{"value":"success"}],"title":"3.5.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.5.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no known security issues.<\/p>\n","value":"<p><span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">There are no known security issues.<\/span><\/p>\r\n"}],"standards":[],"subprojects":[],"themes":[],"title":"3.5.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.5.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-06-23 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>maintenance release containing the bug fixes listed <a href=\"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.1\/bugs\">here<\/a><\/p>\n","summary":"","value":"<p>maintenance release containing the bug fixes listed <a href=\"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.1\/bugs\">here<\/a><\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.4.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-06-18 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Planned features for 3.4.0:<\/p>\n<ul><li>\n\t\tinclude new features from 3.1-3.3 which will be shipped separate from release train<\/li>\n<li>\n\t\tthese minor releases will be contributed to the respective Luna milestones: 3.1 (Luna M2), 3.2 (Luna M4), 3.3 (Luna M6)<\/li>\n<li>\n\t\t3.2.0 was also contributed to Kepler SR2<\/li>\n<li>\n\t\tsupport interactive rebase (released with 3.2)<\/li>\n<li>\n\t\tsupport symbolic links on posix operating systems (partial support with 3.3)<\/li>\n<li>\n\t\tsupport HTTP communication using Apache httpclient (released with 3.3)<\/li>\n<li>\n\t\tpreliminary support for merge drivers (only programmatic configuration, configuration via git attributes to be added later)<\/li>\n<li>\n\t\tbinary merge driver<\/li>\n<li>\n\t\tPerformance improvements<\/li>\n<li>\n\t\tBug fixes<\/li>\n<\/ul>","value":"<p style=\"margin: 0px 0px 3px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: Arial, Helvetica, sans-serif; line-height: 16.363636016845703px; color: rgb(0, 0, 0);\">Planned features for 3.4.0:<\/p>\r\n<ul style=\"margin: 0px 0px 20px; padding-right: 0px; padding-left: 1.2em; border: 0px; outline: 0px; vertical-align: baseline; font-family: Arial, Helvetica, sans-serif; line-height: 16.363636016845703px; list-style-position: initial; list-style-image: initial; color: rgb(0, 0, 0);\">\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\tinclude new features from 3.1-3.3 which will be shipped separate from release train<\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\tthese minor releases will be contributed to the respective Luna milestones: 3.1 (Luna M2), 3.2 (Luna M4), 3.3 (Luna M6)<\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\t3.2.0 was also contributed to Kepler SR2<\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\tsupport interactive rebase (released with 3.2)<\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\tsupport symbolic links on posix operating systems (partial support with 3.3)<\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\tsupport HTTP communication using Apache httpclient (released with 3.3)<\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\t<span style=\"font-family: arial, sans-serif; font-size: 12.727272033691406px;\">preliminary support for merge drivers (only programmatic configuration,&nbsp;configuration via&nbsp;git attributes to be added later)<\/span><\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\t<span style=\"font-family: arial, sans-serif; font-size: 12.727272033691406px;\">binary merge driver<\/span><\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\t<span style=\"font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">Performance improvements<\/span><\/li>\r\n\t<li style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">\r\n\t\tBug fixes<\/li>\r\n<\/ul>\r\n"}],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-06-11 00:00:00"}],"links":[{"attributes":[],"title":"Release Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.4.0"}],"state":[{"value":"success"}],"title":"3.4.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.4.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.4.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.4.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-04-17 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.3.2","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.3.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-03-25 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.3.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.3.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-02-28 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[{"format":"filtered_html","safe_summary":"","safe_value":"<p>Release Review<\/p>","summary":"","value":"<p>Release Review<\/p>\r\n"}],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2014-02-26 00:00:00"}],"links":[{"attributes":[],"title":"Review documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=240138"}],"project":[{"id":"technology.egit"},{"id":"technology.jgit"}],"reference":[{"title":"3.3.0"},{"title":"3.3.0"}],"state":[{"value":"success"}],"title":"3.3.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.egit\/reviews\/3.3.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.3.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.3.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-12-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>3.2.0 will also be contributed to Kepler SR2 (Feb 28, 2014)<\/p>\n","summary":"","value":"<p style=\"margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: baseline; font-family: inherit; font-size: inherit; font-style: inherit; font-variant: inherit; line-height: inherit;\">3.2.0 will also be contributed to Kepler SR2 (Feb 28, 2014)<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[{"format":"filtered_html","safe_summary":"","safe_value":"<p>Release Review<\/p>","summary":"","value":"<p>Release Review<\/p>\r\n"}],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-12-18 00:00:00"}],"links":[{"attributes":[],"title":"Review documentation","url":"https:\/\/projects.eclipse.org\/projects\/technology.egit\/reviews\/3.2.0-release-review"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.2.0"}],"state":[{"value":"success"}],"title":"3.2.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.2.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.2.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.2.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-10-02 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>New features:<\/p>\n<ul><li>\n\t\tSupport for git archive command<\/li>\n<li>\n\t\tAdd path option to StatusCommand<\/li>\n<li>\n\t\tEnable LsRemoteCommand to work without local repository<\/li>\n<li>\n\t\tMake gc command a public command in jgit command line interface<\/li>\n<li>\n\t\tAdd --quiet flag to fetch command in jgit command line interface<\/li>\n<\/ul><p>Updates of 3rd party dependencies<\/p>\n<ul><li>\n\t\tupdate to Jetty 7.6.11.v20130520<\/li>\n<li>\n\t\tupdate to JUnit 4.11.0<\/li>\n<li>\n\t\tupdate target platform to Orbit build <a href=\"http:\/\/download.eclipse.org\/tools\/orbit\/downloads\/drops\/R20130827064939\/\">R20130827064939<\/a><\/li>\n<\/ul><p>Releng<\/p>\n<ul><li>\n\t\tupdate build to Tycho 0.18.0<\/li>\n<li>\n\t\tupdate Maven plugins<\/li>\n<li>\n\t\tupdate build to use CBI jarsigner plugin<\/li>\n<li>\n\t\tmoved build jobs to https:\/\/hudson.eclipse.org\/egit\/<\/li>\n<\/ul><p>Bug fixes<\/p>\n","summary":"","value":"<p>New features:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tSupport for git archive command<\/li>\r\n\t<li>\r\n\t\tAdd path option to StatusCommand<\/li>\r\n\t<li>\r\n\t\tEnable LsRemoteCommand to work without local repository<\/li>\r\n\t<li>\r\n\t\tMake gc command a public command in jgit command line interface<\/li>\r\n\t<li>\r\n\t\tAdd --quiet flag to fetch command in jgit command line interface<\/li>\r\n<\/ul>\r\n<p>Updates of 3rd party dependencies<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tupdate to Jetty 7.6.11.v20130520<\/li>\r\n\t<li>\r\n\t\tupdate to JUnit 4.11.0<\/li>\r\n\t<li>\r\n\t\tupdate target platform to Orbit build&nbsp;<a href=\"http:\/\/download.eclipse.org\/tools\/orbit\/downloads\/drops\/R20130827064939\/\" style=\"font-family: arial, helvetica, geneva; font-size: 13.600000381469727px;\">R20130827064939<\/a><\/li>\r\n<\/ul>\r\n<p>Releng<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tupdate build to Tycho 0.18.0<\/li>\r\n\t<li>\r\n\t\tupdate Maven plugins<\/li>\r\n\t<li>\r\n\t\tupdate build to use CBI jarsigner plugin<\/li>\r\n\t<li>\r\n\t\tmoved build jobs to&nbsp;https:\/\/hudson.eclipse.org\/egit\/<\/li>\r\n<\/ul>\r\n<p>Bug fixes<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[{"format":"filtered_html","safe_summary":"","safe_value":"<p>Release Review<\/p>","summary":"","value":"<p>Release Review<\/p>\r\n"}],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-10-02 00:00:00"}],"links":[{"attributes":[],"title":"Review documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi"},{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.1.0"}],"state":[{"value":"success"}],"title":"3.1.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.1.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.1.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.1.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-09-27 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Maintenance release to be shipped with Kepler SR1<\/p>\n","summary":"","value":"<p>Maintenance release to be shipped with Kepler SR1<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.0.2","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.0.2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-06-26 00:00:00"}],"deliverables":[{"format":"filtered_html","safe_value":"<p>Planned features for 3.0.0:<\/p>\n<ul><li>\n\t\tsupport recursive merge strategy <img alt=\"yes\" height=\"20\" src=\"https:\/\/projects.eclipse.org\/sites\/all\/libraries\/ckeditor\/plugins\/smiley\/images\/thumbs_up.gif\" title=\"yes\" width=\"20\" \/><\/li>\n<li>\n\t\tcompressed bitmap index support to speedup fetch and clone <img alt=\"yes\" height=\"20\" src=\"https:\/\/projects.eclipse.org\/sites\/all\/libraries\/ckeditor\/plugins\/smiley\/images\/thumbs_up.gif\" title=\"yes\" width=\"20\" \/><\/li>\n<li>\n\t\tAPI cleanup<\/li>\n<li>\n\t\toptional support for symlinks on Java 7<\/li>\n<li>\n\t\toptional support for lstat, symlinks and readdir using JNI based native module on Mac\/Linux (tentative)<\/li>\n<li>\n\t\tNameRevCommand for describing IDs in terms of refnames (see git name-rev)<\/li>\n<li>\n\t\tBug fixes\n<ul><li>\n\t\t\t\tfix <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=389305\" rel=\"nofollow\">bug 389305<\/a> \"Running gc twice corrupts repository on Windows\" <img alt=\"yes\" height=\"20\" src=\"https:\/\/projects.eclipse.org\/sites\/all\/libraries\/ckeditor\/plugins\/smiley\/images\/thumbs_up.gif\" title=\"yes\" width=\"20\" \/><\/li>\n<\/ul><\/li>\n<\/ul>","value":"<p>Planned features for 3.0.0:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tsupport recursive merge strategy <img alt=\"yes\" height=\"20\" src=\"https:\/\/projects.eclipse.org\/sites\/all\/libraries\/ckeditor\/plugins\/smiley\/images\/thumbs_up.gif\" title=\"yes\" width=\"20\" \/><\/li>\r\n\t<li>\r\n\t\tcompressed bitmap index support to speedup fetch and clone <img alt=\"yes\" height=\"20\" src=\"https:\/\/projects.eclipse.org\/sites\/all\/libraries\/ckeditor\/plugins\/smiley\/images\/thumbs_up.gif\" title=\"yes\" width=\"20\" \/><\/li>\r\n\t<li>\r\n\t\tAPI cleanup<\/li>\r\n\t<li>\r\n\t\toptional support for symlinks on Java 7<\/li>\r\n\t<li>\r\n\t\toptional support for lstat, symlinks and readdir using JNI based native module on Mac\/Linux (tentative)<\/li>\r\n\t<li>\r\n\t\tNameRevCommand for describing IDs in terms of refnames (see git name-rev)<\/li>\r\n\t<li>\r\n\t\tBug fixes\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tfix <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=389305\">bug 389305<\/a> &quot;Running gc twice corrupts repository on Windows&quot;&nbsp;<img alt=\"yes\" height=\"20\" src=\"https:\/\/projects.eclipse.org\/sites\/all\/libraries\/ckeditor\/plugins\/smiley\/images\/thumbs_up.gif\" title=\"yes\" width=\"20\" \/><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[{"format":"filtered_html","safe_summary":"","safe_value":"<p>Release Review<\/p>","summary":"","value":"<p>Release Review<\/p>\r\n"}],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-06-12 00:00:00"}],"links":[{"attributes":[],"title":"Review documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi"},{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"3.0.0"}],"state":[{"value":"success"}],"title":"3.0.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/reviews\/3.0.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"3.0.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/3.0.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-03-01 00:00:00"}],"deliverables":[],"description":[{"format":"filtered_html","safe_summary":"","safe_value":"<p>Maintenance release fixing bug https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=401249<\/p>","summary":"","value":"Maintenance release fixing bug https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=401249"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"2.3.1","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/releases\/2.3.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-02-22 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":"","url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/2.3"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2013-02-20 00:00:00"}],"links":[{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=226938"},{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=226924"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"2.3.0"}],"state":[{"value":"success"}],"title":"2.3.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/2.3.0-release-review-6"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"2.3.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit\/release\/2.3.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-12-20 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/2.2"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-12-19 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=224874"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=224550"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"2.2.0"}],"state":[{"value":"success"}],"title":"2.2.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/2.2.0-release-review-7"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"2.2.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/2.2.0-12","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-09-26 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/2.1"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-09-26 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=221258"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=220951"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"2.1.0"}],"state":[{"value":"success"}],"title":"2.1.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/2.1.0-release-review-7"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"2.1.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/2.1.0-16","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-06-27 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/2.0"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-06-13 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=216948"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=216799"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"2.0.0"}],"state":[{"value":"success"}],"title":"2.0.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/2.0.0-release-review-10"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"2.0.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/2.0.0-27","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-02-17 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/EGit\/New_and_Noteworthy\/1.3"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2012-02-15 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=210681"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=210686"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"1.3.0"}],"state":[{"value":"success"}],"title":"1.3.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/1.3.0-release-review-3"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"1.3.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/1.3.0-8","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-12-23 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/EGit\/New_and_Noteworthy\/1.2"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-12-21 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=208291"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=208386"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"1.2.0"}],"state":[{"value":"success"}],"title":"1.2.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/1.2.0-release-review-9"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"1.2.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/1.2.0-17","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-09-22 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/EGit\/New_and_Noteworthy\/1.1"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-09-21 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=203409"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=203414"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"1.1.0"}],"state":[{"value":"success"}],"title":"1.1.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/content\/1.1.0-release-review-11"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"1.1.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/1.1.0-23","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-06-22 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/EGit\/New_and_Noteworthy\/1.0.0"}],"parent_project":[{"id":"technology.jgit"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-06-15 00:00:00"}],"links":[{"attributes":[],"title":"Approved IP Log","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=197635"},{"attributes":[],"title":"Review Documentation","url":"https:\/\/bugs.eclipse.org\/bugs\/attachment.cgi?id=197461"}],"project":[{"id":"technology.jgit"}],"reference":[{"title":"1.0.0"}],"state":[{"value":"success"}],"title":"1.0.0 Release Review","top_level":[{"id":"technology"}],"type":[{"value":"release"},{"value":"graduation"}],"url":"https:\/\/projects.eclipse.org\/content\/1.0.0-release-review-25"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"1.0.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/1.0.0-48","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-05-03 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/0.12"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.12.1","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.12.1-0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2011-02-21 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/0.11"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.11.3","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.11.3-0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2010-12-17 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/0.10"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.10.1","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.10.1-1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2010-09-17 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/EGit\/New_and_Noteworthy\/0.9"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.9.3","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.9.3-2","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2010-06-14 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"http:\/\/wiki.eclipse.org\/JGit\/New_and_Noteworthy\/0.8"}],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.8.4","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.8.4-0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2010-03-22 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.7.1","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.7.1-7","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2010-03-19 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"technology.jgit"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"0.7.0","type":[{}],"url":"https:\/\/projects.eclipse.org\/projects\/release\/0.7.0-25","usability":[]}],"scope":[{"format":"full_html","safe_value":"<p>Eclipse JGit™ is a pure Java implementation of the Git version control system.<\/p>\n","value":"<p>Eclipse JGit&trade; is a pure Java implementation of the Git version control system.<\/p>\r\n"}],"source_repo":[{"name":"jgit\/jgit","path":"\/gitroot\/jgit\/jgit.git","type":"git","url":"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/jgit\/jgit"}],"spec_working_group":[],"state":[{"value":"Regular"}],"tags":[],"team_project_sets":[{"attributes":[],"title":"oomph installer for jgit and egit","url":"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/egit\/egit\/+\/refs\/heads\/master\/tools\/oomph\/EGit.setup"}],"techology_types":[{"tid":"26"},{"tid":"24"}],"title":"Eclipse JGit™: Java implementation of Git","update_sites":[{"attributes":[],"title":"jgit and egit update site - releases","url":"https:\/\/download.eclipse.org\/egit\/updates"},{"attributes":[],"title":"jgit and egit update site - master branch","url":"https:\/\/download.eclipse.org\/egit\/updates-nightly"}],"url":"https:\/\/projects.eclipse.org\/projects\/technology.jgit","website_url":[{"attributes":[],"title":null,"url":"https:\/\/www.eclipse.org\/jgit\/"}],"wiki_url":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/JGit"}],"working_group":[{"tid":"1535"}]},"pmi_url":"https:\/\/projects.eclipse.org\/json\/project\/technology.jgit"}