Filters(Configuration config) { Date dateToStartKeepingOneSnapshotByDay = getDateFromHours(config, PurgeConstants.HOURS_BEFORE_KEEPING_ONLY_ONE_SNAPSHOT_BY_DAY); Date dateToStartKeepingOneSnapshotByWeek = getDateFromWeeks(config, PurgeConstants.WEEKS_BEFORE_KEEPING_ONLY_ONE_SNAPSHOT_BY_WEEK); Date dateToStartKeepingOneSnapshotByMonth = getDateFromWeeks(config, PurgeConstants.WEEKS_BEFORE_KEEPING_ONLY_ONE_SNAPSHOT_BY_MONTH); Date dateToStartKeepingOnlyAnalysisWithVersion = getDateFromWeeks(config, PurgeConstants.WEEKS_BEFORE_KEEPING_ONLY_ANALYSES_WITH_VERSION); Date dateToStartDeletingAllSnapshots = getDateFromWeeks(config, PurgeConstants.WEEKS_BEFORE_DELETING_ALL_SNAPSHOTS); all.add(new KeepOneFilter(dateToStartKeepingOneSnapshotByWeek, dateToStartKeepingOneSnapshotByDay, Calendar.DAY_OF_YEAR, "day")); all.add(new KeepOneFilter(dateToStartKeepingOneSnapshotByMonth, dateToStartKeepingOneSnapshotByWeek, Calendar.WEEK_OF_YEAR, "week")); all.add(new KeepOneFilter(dateToStartDeletingAllSnapshots, dateToStartKeepingOneSnapshotByMonth, Calendar.MONTH, "month")); all.add(new KeepWithVersionFilter(dateToStartKeepingOnlyAnalysisWithVersion)); all.add(new DeleteAllFilter(dateToStartDeletingAllSnapshots)); }
@Override public List<PurgeableAnalysisDto> filter(List<PurgeableAnalysisDto> history) { List<Interval> intervals = Interval.group(history, start, end, dateField); List<PurgeableAnalysisDto> result = Lists.newArrayList(); for (Interval interval : intervals) { appendSnapshotsToDelete(interval, result); } return result; }
@VisibleForTesting void doClean(String rootUuid, List<Filter> filters, DbSession session) { List<PurgeableAnalysisDto> history = new ArrayList<>(selectAnalysesOfComponent(rootUuid, session)); for (Filter filter : filters) { filter.log(); history.removeAll(delete(rootUuid, filter.filter(history), session)); } }
private static void appendSnapshotsToDelete(Interval interval, List<PurgeableAnalysisDto> toDelete) { if (interval.count() > 1) { List<PurgeableAnalysisDto> deletables = Lists.newArrayList(); List<PurgeableAnalysisDto> toKeep = Lists.newArrayList(); for (PurgeableAnalysisDto snapshot : interval.get()) { if (isDeletable(snapshot)) { deletables.add(snapshot); } else { toKeep.add(snapshot); } } if (!toKeep.isEmpty()) { toDelete.addAll(deletables); } else if (deletables.size() > 1) { // keep last snapshot toDelete.addAll(deletables.subList(0, deletables.size() - 1)); } } }
@Test public void shouldKeepNonDeletableSnapshots() { Filter filter = new KeepOneFilter(DateUtils.parseDate("2011-03-25"), DateUtils.parseDate("2011-08-25"), Calendar.MONTH, "month"); List<PurgeableAnalysisDto> toDelete = filter.filter(Arrays.asList( DbCleanerTestUtils.createAnalysisWithDate("u1", "2011-05-01"), // to be deleted DbCleanerTestUtils.createAnalysisWithDate("u2", "2011-05-02").setLast(true), DbCleanerTestUtils.createAnalysisWithDate("u3", "2011-05-19").setHasEvents(true).setLast(false), DbCleanerTestUtils.createAnalysisWithDate("u4", "2011-05-23") // to be deleted )); assertThat(toDelete).hasSize(2); assertThat(analysisUuids(toDelete)).contains("u1", "u4"); }
@Test public void shouldNotJoinMonthsOfDifferentYears() { List<PurgeableAnalysisDto> snapshots = Arrays.asList( DbCleanerTestUtils.createAnalysisWithDate("u1", "2010-04-03"), DbCleanerTestUtils.createAnalysisWithDate("u2", "2011-04-13") ); List<Interval> intervals = Interval.group(snapshots, DateUtils.parseDateTime("2010-01-01T00:00:00+0100"), DateUtils.parseDateTime("2011-12-31T00:00:00+0100"), Calendar.MONTH); assertThat(intervals.size()).isEqualTo(2); assertThat(intervals.get(0).count()).isEqualTo(1); assertThat(calendarField(intervals.get(0), Calendar.MONTH)).isEqualTo((Calendar.APRIL)); assertThat(calendarField(intervals.get(0), Calendar.YEAR)).isEqualTo((2010)); assertThat(intervals.get(1).count()).isEqualTo(1); assertThat(calendarField(intervals.get(1), Calendar.MONTH)).isEqualTo((Calendar.APRIL)); assertThat(calendarField(intervals.get(1), Calendar.YEAR)).isEqualTo((2011)); }
@Test public void shouldIgnoreTimeWhenGroupingByIntervals() { List<PurgeableAnalysisDto> snapshots = Arrays.asList( DbCleanerTestUtils.createAnalysisWithDateTime("u1", "2011-05-25T00:16:48+0100"), DbCleanerTestUtils.createAnalysisWithDateTime("u2", "2012-01-26T00:16:48+0100"), DbCleanerTestUtils.createAnalysisWithDateTime("u3", "2012-01-27T00:16:48+0100") ); List<Interval> intervals = Interval.group(snapshots, DateUtils.parseDateTime("2011-05-25T00:00:00+0100"), DateUtils.parseDateTime("2012-01-26T00:00:00+0100"), Calendar.MONTH); assertThat(intervals.size()).isEqualTo(1); assertThat(intervals.get(0).count()).isEqualTo(1); assertThat(intervals.get(0).get().get(0).getAnalysisUuid()).isEqualTo(("u2")); } }
@Test public void doClean() { PurgeDao dao = mock(PurgeDao.class); DbSession session = mock(DbSession.class); when(dao.selectPurgeableAnalyses("uuid_123", session)).thenReturn(Arrays.asList( new PurgeableAnalysisDto().setAnalysisId(999).setAnalysisUuid("u999").setDate(System2.INSTANCE.now()), new PurgeableAnalysisDto().setAnalysisId(456).setAnalysisUuid("u456").setDate(System2.INSTANCE.now()) )); Filter filter1 = newFirstSnapshotInListFilter(); Filter filter2 = newFirstSnapshotInListFilter(); PurgeProfiler profiler = new PurgeProfiler(); DefaultPeriodCleaner cleaner = new DefaultPeriodCleaner(dao, profiler); cleaner.doClean("uuid_123", Arrays.asList(filter1, filter2), session); InOrder inOrder = Mockito.inOrder(dao, filter1, filter2); inOrder.verify(filter1).log(); inOrder.verify(dao, times(1)).deleteAnalyses(eq(session), eq(profiler), eq(ImmutableList.of(new IdUuidPair(999, "u999")))); inOrder.verify(filter2).log(); inOrder.verify(dao, times(1)).deleteAnalyses(eq(session), eq(profiler), eq(ImmutableList.of(new IdUuidPair(456, "u456")))); inOrder.verifyNoMoreInteractions(); }
@Test public void shouldDeleteAllSnapshotsPriorToDate() { Filter filter = new DeleteAllFilter(DateUtils.parseDate("2011-12-25")); List<PurgeableAnalysisDto> toDelete = filter.filter(Arrays.asList( DbCleanerTestUtils.createAnalysisWithDate("u1", "2010-01-01"), DbCleanerTestUtils.createAnalysisWithDate("u2", "2010-12-25"), DbCleanerTestUtils.createAnalysisWithDate("u3", "2012-01-01") )); assertThat(toDelete).extracting("analysisUuid").containsOnly("u1", "u2"); } }
@Test public void keep_only_analyses_with_a_version() { Filter underTest = new KeepWithVersionFilter(parseDate("2015-10-18")); List<PurgeableAnalysisDto> result = underTest.filter(Arrays.asList( DbCleanerTestUtils.createAnalysisWithDate("u1", "2015-10-17").setVersion("V1"), DbCleanerTestUtils.createAnalysisWithDate("u2", "2015-10-17").setVersion(null), DbCleanerTestUtils.createAnalysisWithDate("u3", "2015-10-19").setVersion(null))); assertThat(result).extracting(PurgeableAnalysisDto::getAnalysisUuid).containsExactlyInAnyOrder("u2"); } }
@Test public void call_period_cleaner_index_client_and_purge_dao() { settings.setProperty(PurgeConstants.DAYS_BEFORE_DELETING_CLOSED_ISSUES, 5); underTest.purge(mock(DbSession.class), mock(IdUuidPair.class), settings.asConfig(), emptyList()); verify(periodCleaner).clean(any(), any(), any()); verify(dao).purge(any(), any(), any(), any()); } }
static List<Interval> group(List<PurgeableAnalysisDto> snapshots, Date start, Date end, int calendarField) { List<Interval> intervals = Lists.newArrayList(); GregorianCalendar calendar = new GregorianCalendar(); int lastYear = -1; int lastFieldValue = -1; Interval currentInterval = null; for (PurgeableAnalysisDto snapshot : snapshots) { if (!DateUtils.isSameDay(start, snapshot.getDate()) && snapshot.getDate().after(start) && (snapshot.getDate().before(end) || DateUtils.isSameDay(end, snapshot.getDate()))) { calendar.setTime(snapshot.getDate()); int currentFieldValue = calendar.get(calendarField); int currentYear = calendar.get(Calendar.YEAR); if (lastYear != currentYear || lastFieldValue != currentFieldValue) { currentInterval = new Interval(); intervals.add(currentInterval); } lastFieldValue = currentFieldValue; lastYear = currentYear; if (currentInterval != null) { currentInterval.add(snapshot); } } } return intervals; } }
private Filter newFirstSnapshotInListFilter() { Filter filter1 = mock(Filter.class); when(filter1.filter(anyList())).thenAnswer(invocation -> Collections.singletonList(((List) invocation.getArguments()[0]).iterator().next())); return filter1; } }
@Test public void test_isDeletable() { assertThat(KeepOneFilter.isDeletable(DbCleanerTestUtils.createAnalysisWithDate("u1", "2011-05-01"))).isTrue(); assertThat(KeepOneFilter.isDeletable(DbCleanerTestUtils.createAnalysisWithDate("u1", "2011-05-01").setLast(true))).isFalse(); assertThat(KeepOneFilter.isDeletable(DbCleanerTestUtils.createAnalysisWithDate("u1", "2011-05-01").setHasEvents(true))).isFalse(); }
Filters(Settings settings) { Date dateToStartKeepingOneSnapshotByDay = getDateFromHours(settings, PurgeConstants.HOURS_BEFORE_KEEPING_ONLY_ONE_SNAPSHOT_BY_DAY); Date dateToStartKeepingOneSnapshotByWeek = getDateFromWeeks(settings, PurgeConstants.WEEKS_BEFORE_KEEPING_ONLY_ONE_SNAPSHOT_BY_WEEK); Date dateToStartKeepingOneSnapshotByMonth = getDateFromWeeks(settings, PurgeConstants.WEEKS_BEFORE_KEEPING_ONLY_ONE_SNAPSHOT_BY_MONTH); Date dateToStartDeletingAllSnapshots = getDateFromWeeks(settings, PurgeConstants.WEEKS_BEFORE_DELETING_ALL_SNAPSHOTS); all.add(new KeepOneFilter(dateToStartKeepingOneSnapshotByWeek, dateToStartKeepingOneSnapshotByDay, Calendar.DAY_OF_YEAR, "day")); all.add(new KeepOneFilter(dateToStartKeepingOneSnapshotByMonth, dateToStartKeepingOneSnapshotByWeek, Calendar.WEEK_OF_YEAR, "week")); all.add(new KeepOneFilter(dateToStartDeletingAllSnapshots, dateToStartKeepingOneSnapshotByMonth, Calendar.MONTH, "month")); all.add(new DeleteAllFilter(dateToStartDeletingAllSnapshots)); }
@Test public void shouldOnlyOneSnapshotPerInterval() { Filter filter = new KeepOneFilter(DateUtils.parseDate("2011-03-25"), DateUtils.parseDate("2011-08-25"), Calendar.MONTH, "month"); List<PurgeableAnalysisDto> toDelete = filter.filter(Arrays.asList( DbCleanerTestUtils.createAnalysisWithDate("u1", "2010-01-01"), // out of scope -> keep DbCleanerTestUtils.createAnalysisWithDate("u2", "2011-05-01"), // may -> keep DbCleanerTestUtils.createAnalysisWithDate("u3", "2011-05-02"), // may -> to be deleted DbCleanerTestUtils.createAnalysisWithDate("u4", "2011-05-19"), // may -> to be deleted DbCleanerTestUtils.createAnalysisWithDate("u5", "2011-06-01"), // june -> keep DbCleanerTestUtils.createAnalysisWithDate("u6", "2012-01-01") // out of scope -> keep )); assertThat(toDelete).hasSize(2); assertThat(analysisUuids(toDelete)).containsOnly("u2", "u3"); }
@Test public void shouldGroupByIntervals() { List<PurgeableAnalysisDto> snapshots = Arrays.asList( DbCleanerTestUtils.createAnalysisWithDate("u1", "2011-04-03"), DbCleanerTestUtils.createAnalysisWithDate("u2", "2011-05-01"), DbCleanerTestUtils.createAnalysisWithDate("u3", "2011-05-19"), DbCleanerTestUtils.createAnalysisWithDate("u4", "2011-06-02"), DbCleanerTestUtils.createAnalysisWithDate("u5", "2011-06-20"), DbCleanerTestUtils.createAnalysisWithDate("u6", "2012-06-29") // out of scope ); List<Interval> intervals = Interval.group(snapshots, DateUtils.parseDate("2010-01-01"), DateUtils.parseDate("2011-12-31"), Calendar.MONTH); assertThat(intervals.size()).isEqualTo(3); assertThat(intervals.get(0).count()).isEqualTo(1); assertThat(calendarField(intervals.get(0), Calendar.MONTH)).isEqualTo((Calendar.APRIL)); assertThat(intervals.get(1).count()).isEqualTo(2); assertThat(calendarField(intervals.get(1), Calendar.MONTH)).isEqualTo((Calendar.MAY)); assertThat(intervals.get(2).count()).isEqualTo(2); assertThat(calendarField(intervals.get(2), Calendar.MONTH)).isEqualTo((Calendar.JUNE)); }
public ProjectCleaner purge(DbSession session, IdUuidPair rootId, Configuration projectConfig, Collection<String> disabledComponentUuids) { long start = System.currentTimeMillis(); profiler.reset(); PurgeConfiguration configuration = newDefaultPurgeConfiguration(projectConfig, rootId, disabledComponentUuids); periodCleaner.clean(session, configuration.rootProjectIdUuid().getUuid(), projectConfig); purgeDao.purge(session, configuration, purgeListener, profiler); session.commit(); logProfiling(start, projectConfig); return this; }