diff options
7 files changed, 203 insertions, 45 deletions
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserBadlyFormattedTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserBadlyFormattedTest.java new file mode 100644 index 0000000000..09389591e0 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserBadlyFormattedTest.java @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2012, Christian Halstrick + * and other copyright owners as documented in the project's IP log. + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Distribution License v1.0 which + * accompanies this distribution, is reproduced below, and is + * available at http://www.eclipse.org/org/documents/edl-v10.php + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * - Neither the name of the Eclipse Foundation, Inc. nor the + * names of its contributors may be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.eclipse.jgit.util; + +import static org.junit.Assert.fail; + +import java.text.ParseException; +import java.util.Calendar; +import java.util.GregorianCalendar; + +import org.junit.experimental.theories.DataPoints; +import org.junit.experimental.theories.Theories; +import org.junit.experimental.theories.Theory; +import org.junit.runner.RunWith; + +/** + * Tests which assert that unparseable Strings lead to ParseExceptions + */ +@RunWith(Theories.class) +public class GitDateParserBadlyFormattedTest { + private String dateStr; + + public GitDateParserBadlyFormattedTest(String dateStr) { + this.dateStr = dateStr; + } + + @DataPoints + static public String[] getDataPoints() { + return new String[] { "", "1970", "3000.3000.3000", "3 yesterday ago", + "now yesterday ago", "yesterdays", "3.day. 2.week.ago", + "day ago", "Gra Feb 21 15:35:00 2007 +0100", + "Sun Feb 21 15:35:00 2007 +0100", + "Wed Feb 21 15:35:00 Grand +0100" }; + } + + @Theory + public void badlyFormattedWithExplicitRef() { + Calendar ref = new GregorianCalendar(SystemReader.getInstance() + .getTimeZone(), SystemReader.getInstance().getLocale()); + try { + GitDateParser.parse(dateStr, ref); + fail("The expected ParseException while parsing '" + dateStr + + "' did not occur."); + } catch (ParseException e) { + // expected + } + } + + @Theory + public void badlyFormattedWithoutRef() { + try { + GitDateParser.parse(dateStr, null); + fail("The expected ParseException while parsing '" + dateStr + + "' did not occur."); + } catch (ParseException e) { + // expected + } + } +} diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserTest.java index 11e2e513c6..6b0632aef0 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserTest.java @@ -62,30 +62,7 @@ public class GitDateParserTest { } @Test - public void badlyFormatted() { - Calendar ref = new GregorianCalendar(SystemReader.getInstance() - .getTimeZone(), SystemReader.getInstance().getLocale()); - Assert.assertNull(GitDateParser.parse("foo", ref)); - Assert.assertNull(GitDateParser.parse("", ref)); - Assert.assertNull(GitDateParser.parse("", null)); - Assert.assertNull(GitDateParser.parse("1970", ref)); - Assert.assertNull(GitDateParser.parse("3000.3000.3000", ref)); - Assert.assertNull(GitDateParser.parse("3 yesterday ago", ref)); - Assert.assertNull(GitDateParser.parse("now yesterday ago", ref)); - Assert.assertNull(GitDateParser.parse("yesterdays", ref)); - Assert.assertNull(GitDateParser.parse("3.day. 2.week.ago", ref)); - Assert.assertNull(GitDateParser.parse("day ago", ref)); - Assert.assertNull(GitDateParser.parse("Gra Feb 21 15:35:00 2007 +0100", - null)); - Assert.assertNull(GitDateParser.parse("Sun Feb 21 15:35:00 2007 +0100", - null)); - Assert.assertNull(GitDateParser.parse( - "Wed Feb 21 15:35:00 Grand +0100", - null)); - } - - @Test - public void yesterday() { + public void yesterday() throws ParseException { GregorianCalendar cal = new GregorianCalendar(SystemReader .getInstance().getTimeZone(), SystemReader.getInstance() .getLocale()); @@ -100,6 +77,17 @@ public class GitDateParserTest { } @Test + public void never() throws ParseException { + GregorianCalendar cal = new GregorianCalendar(SystemReader + .getInstance().getTimeZone(), SystemReader.getInstance() + .getLocale()); + Date parse = GitDateParser.parse("never", cal); + Assert.assertEquals(GitDateParser.NEVER, parse); + parse = GitDateParser.parse("never", null); + Assert.assertEquals(GitDateParser.NEVER, parse); + } + + @Test public void now() throws ParseException { String dateStr = "2007-02-21 15:35:00 +0100"; Date refDate = SystemReader.getInstance() diff --git a/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties b/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties index fd9cea4046..8a288cd070 100644 --- a/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties +++ b/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties @@ -55,6 +55,7 @@ cannotMatchOnEmptyString=Cannot match on empty string. cannotMoveIndexTo=Cannot move index to {0} cannotMovePackTo=Cannot move pack to {0} cannotOpenService=cannot open {0} +cannotParseDate=The date specification "{0}" could not be parsed with the following formats: {1} cannotParseGitURIish=Cannot parse Git URI-ish cannotPullOnARepoWithState=Cannot pull into a repository with state: {0} cannotRead=Cannot read {0} diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java index ec3c37d8ca..d70481450c 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java @@ -115,6 +115,7 @@ public class JGitText extends TranslationBundle { /***/ public String cannotMoveIndexTo; /***/ public String cannotMovePackTo; /***/ public String cannotOpenService; + /***/ public String cannotParseDate; /***/ public String cannotParseGitURIish; /***/ public String cannotPullOnARepoWithState; /***/ public String cannotRead; diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ConfigConstants.java b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ConfigConstants.java index aaa427bae6..483482e18e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/lib/ConfigConstants.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/lib/ConfigConstants.java @@ -75,6 +75,9 @@ public class ConfigConstants { /** The "submodule" section */ public static final String CONFIG_SUBMODULE_SECTION = "submodule"; + /** The "gc" section */ + public static final String CONFIG_GC_SECTION = "gc"; + /** The "pack" section */ public static final String CONFIG_PACK_SECTION = "pack"; @@ -181,4 +184,7 @@ public class ConfigConstants { /** The "precomposeunicode" key */ public static final String CONFIG_KEY_PRECOMPOSEUNICODE = "precomposeunicode"; + + /** The "pruneexpire" key */ + public static final String CONFIG_KEY_PRUNEEXPIRE = "pruneexpire"; } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/GC.java b/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/GC.java index 1c2b959323..2e7208cd80 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/GC.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/GC.java @@ -50,9 +50,11 @@ import java.io.OutputStream; import java.nio.channels.Channels; import java.nio.channels.FileChannel; import java.text.MessageFormat; +import java.text.ParseException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; @@ -68,6 +70,7 @@ import org.eclipse.jgit.errors.IncorrectObjectTypeException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.NoWorkTreeException; import org.eclipse.jgit.internal.JGitText; +import org.eclipse.jgit.lib.ConfigConstants; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.FileMode; import org.eclipse.jgit.lib.NullProgressMonitor; @@ -83,6 +86,7 @@ import org.eclipse.jgit.storage.pack.PackWriter; import org.eclipse.jgit.treewalk.TreeWalk; import org.eclipse.jgit.treewalk.filter.TreeFilter; import org.eclipse.jgit.util.FileUtils; +import org.eclipse.jgit.util.GitDateParser; /** * A garbage collector for git {@link FileRepository}. Instances of this class @@ -92,11 +96,15 @@ import org.eclipse.jgit.util.FileUtils; * adapted to FileRepositories. */ public class GC { + private static final String PRUNE_EXPIRE_DEFAULT = "2.weeks.ago"; + private final FileRepository repo; private ProgressMonitor pm; - private long expireAgeMillis; + private long expireAgeMillis = -1; + + private Date expire; /** * the refs which existed during the last call to {@link #repack()}. This is @@ -123,7 +131,6 @@ public class GC { public GC(FileRepository repo) { this.repo = repo; this.pm = NullProgressMonitor.INSTANCE; - this.expireAgeMillis = 14 * 24 * 60 * 60 * 1000L; } /** @@ -137,8 +144,11 @@ public class GC { * * @return the collection of {@link PackFile}'s which are newly created * @throws IOException + * @throws ParseException + * If the configuration parameter "gc.pruneexpire" couldn't be + * parsed */ - public Collection<PackFile> gc() throws IOException { + public Collection<PackFile> gc() throws IOException, ParseException { pm.start(6 /* tasks */); packRefs(); // TODO: implement reflog_expire(pm, repo); @@ -250,11 +260,27 @@ public class GC { * a set of objects which should explicitly not be pruned * * @throws IOException + * @throws ParseException + * If the configuration parameter "gc.pruneexpire" couldn't be + * parsed */ - public void prune(Set<ObjectId> objectsToKeep) - throws IOException { - long expireDate = (expireAgeMillis == 0) ? Long.MAX_VALUE : System - .currentTimeMillis() - expireAgeMillis; + public void prune(Set<ObjectId> objectsToKeep) throws IOException, + ParseException { + long expireDate = Long.MAX_VALUE; + + if (expire == null && expireAgeMillis == -1) { + String pruneExpireStr = repo.getConfig().getString( + ConfigConstants.CONFIG_GC_SECTION, null, + ConfigConstants.CONFIG_KEY_PRUNEEXPIRE); + if (pruneExpireStr == null) + pruneExpireStr = PRUNE_EXPIRE_DEFAULT; + expire = GitDateParser.parse(pruneExpireStr, null); + expireAgeMillis = -1; + } + if (expire != null) + expireDate = expire.getTime(); + if (expireAgeMillis != -1) + expireDate = System.currentTimeMillis() - expireAgeMillis; // Collect all loose objects which are old enough, not referenced from // the index and not in objectsToKeep @@ -807,5 +833,21 @@ public class GC { */ public void setExpireAgeMillis(long expireAgeMillis) { this.expireAgeMillis = expireAgeMillis; + expire = null; + } + + /** + * During gc() or prune() each unreferenced, loose object which has been + * created or modified after <code>expire</code> will not be pruned. Only + * older objects may be pruned. If set to null then every object is a + * candidate for pruning. + * + * @param expire + * minimal age of objects to be pruned in milliseconds. + */ + public void setExpire(Date expire) { + this.expire = expire; + expireAgeMillis = -1; } + } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/GitDateParser.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/GitDateParser.java index 04ef553b05..f1743d4f16 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/util/GitDateParser.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/GitDateParser.java @@ -42,6 +42,7 @@ */ package org.eclipse.jgit.util; +import java.text.MessageFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; @@ -50,6 +51,8 @@ import java.util.GregorianCalendar; import java.util.HashMap; import java.util.Map; +import org.eclipse.jgit.internal.JGitText; + /** * Parses strings with time and date specifications into {@link Date}. * @@ -59,6 +62,12 @@ import java.util.Map; * understands. */ public class GitDateParser { + /** + * The Date representing never. Though this is a concrete value, most + * callers are adviced to avoid depending on the actual value. + */ + public static final Date NEVER = new Date(Long.MAX_VALUE); + // Since SimpleDateFormat instances are expensive to instantiate they should // be cached. Since they are also not threadsafe they are cached using // ThreadLocal. @@ -110,6 +119,7 @@ public class GitDateParser { * relative formats (e.g. "yesterday") the caller can specify the reference * date. These types of strings can be parsed: * <ul> + * <li>"never"</li> * <li>"now"</li> * <li>"yesterday"</li> * <li>"(x) years|months|weeks|days|hours|minutes|seconds ago"<br> @@ -135,32 +145,43 @@ public class GitDateParser { * parser often but wants a consistent starting point for calls.<br> * If set to <code>null</code> then the current time will be used * instead. - * @return the parsed {@link Date} or <code>null</code> if this string was - * not parseable. + * @return the parsed {@link Date} + * @throws ParseException + * if the given dateStr was not recognized */ - public static Date parse(String dateStr, Calendar now) { + public static Date parse(String dateStr, Calendar now) + throws ParseException { dateStr = dateStr.trim(); Date ret; + + if ("never".equalsIgnoreCase(dateStr)) + return NEVER; ret = parse_relative(dateStr, now); if (ret != null) return ret; for (ParseableSimpleDateFormat f : ParseableSimpleDateFormat.values()) { - ret = parse_simple(dateStr, f); - if (ret != null) - return ret; + try { + return parse_simple(dateStr, f); + } catch (ParseException e) { + // simply proceed with the next parser + } } - return null; + ParseableSimpleDateFormat[] values = ParseableSimpleDateFormat.values(); + StringBuilder allFormats = new StringBuilder("\"") + .append(values[0].formatStr); + for (int i = 1; i < values.length; i++) + allFormats.append("\", \"").append(values[i].formatStr); + allFormats.append("\""); + throw new ParseException(MessageFormat.format( + JGitText.get().cannotParseDate, dateStr, allFormats.toString()), 0); } // tries to parse a string with the formats supported by SimpleDateFormat - private static Date parse_simple(String dateStr, ParseableSimpleDateFormat f) { + private static Date parse_simple(String dateStr, ParseableSimpleDateFormat f) + throws ParseException { SimpleDateFormat dateFormat = getDateFormat(f); - try { - dateFormat.setLenient(false); - return dateFormat.parse(dateStr); - } catch (ParseException e) { - return null; - } + dateFormat.setLenient(false); + return dateFormat.parse(dateStr); } // tries to parse a string with a relative time specification |