Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.ranger.audit.utils; import java.util.Calendar; import java.util.Date; import org.apache.commons.lang.StringUtils; public class RollingTimeUtil { public static final String MINUTES = "m"; //minutes public static final String HOURS = "h"; //hours public static final String DAYS = "d"; //days public static final String WEEKS = "w"; //weeks public static final String MONTHS = "M"; //months public static final String YEARS = "y"; //years private static volatile RollingTimeUtil me = null; public static RollingTimeUtil getInstance() { RollingTimeUtil result = me; if (result == null) { synchronized (RollingTimeUtil.class) { result = me; if (result == null) { me = result = new RollingTimeUtil(); } } } return result; } public RollingTimeUtil() { } public Date computeNextRollingTime(String rollingTimePeriod) throws Exception { Date ret = null; if (!StringUtils.isEmpty(rollingTimePeriod)) { String computePeriod = getTimeLiteral(rollingTimePeriod); int timeNumeral = getTimeNumeral(rollingTimePeriod, computePeriod); switch (computePeriod) { case MINUTES: ret = computeTopOfMinuteDate(timeNumeral); break; case HOURS: ret = computeTopOfHourDate(timeNumeral); break; case DAYS: ret = computeTopOfDayDate(timeNumeral); break; case WEEKS: ret = computeTopOfWeekDate(timeNumeral); break; case MONTHS: ret = computeTopofMonthDate(timeNumeral); break; case YEARS: ret = computeTopOfYearDate(timeNumeral); break; } } else { throw new Exception("Unable to compute Next Rolling using the given Rollover period"); } return ret; } public String convertRolloverSecondsToRolloverPeriod(long duration) { final int SECONDS_IN_MINUTE = 60; final int SECONDS_IN_HOUR = 60 * SECONDS_IN_MINUTE; final int SECONDS_IN_DAY = 24 * SECONDS_IN_HOUR; String ret = null; int days = (int) (duration / SECONDS_IN_DAY); duration %= SECONDS_IN_DAY; int hours = (int) (duration / SECONDS_IN_HOUR); duration %= SECONDS_IN_HOUR; int minutes = (int) (duration / SECONDS_IN_MINUTE); if (days != 0) { if (hours == 0 && minutes == 0) { ret = (days + DAYS); } } else if (hours != 0) { if (minutes == 0) { ret = (hours + HOURS); } } else if (minutes != 0) { ret = (minutes + MINUTES); } return ret; } public long computeNextRollingTime(long durationSeconds, Date previousRolloverTime) { long now = System.currentTimeMillis(); long nextRolloverTime = (previousRolloverTime == null) ? now : previousRolloverTime.getTime(); long durationMillis = (durationSeconds < 1 ? 1 : durationSeconds) * 1000; while (nextRolloverTime <= now) { nextRolloverTime += durationMillis; } return nextRolloverTime; } private Date computeTopOfYearDate(int years) { Date ret = null; Calendar calendarStart = Calendar.getInstance(); calendarStart.add(Calendar.YEAR, years); calendarStart.set(Calendar.MONTH, 0); calendarStart.set(Calendar.DAY_OF_MONTH, 1); calendarStart.set(Calendar.HOUR_OF_DAY, 0); calendarStart.clear(Calendar.MINUTE); calendarStart.clear(Calendar.SECOND); calendarStart.clear(Calendar.MILLISECOND); ret = calendarStart.getTime(); return ret; } private Date computeTopofMonthDate(int months) { Date ret = null; Calendar calendarMonth = Calendar.getInstance(); calendarMonth.set(Calendar.DAY_OF_MONTH, 1); calendarMonth.add(Calendar.MONTH, months); calendarMonth.set(Calendar.HOUR_OF_DAY, 0); calendarMonth.clear(Calendar.MINUTE); calendarMonth.clear(Calendar.SECOND); calendarMonth.clear(Calendar.MILLISECOND); ret = calendarMonth.getTime(); return ret; } private Date computeTopOfWeekDate(int weeks) { Date ret = null; Calendar calendarWeek = Calendar.getInstance(); calendarWeek.set(Calendar.DAY_OF_WEEK, calendarWeek.getFirstDayOfWeek()); calendarWeek.add(Calendar.WEEK_OF_YEAR, weeks); calendarWeek.set(Calendar.HOUR_OF_DAY, 0); calendarWeek.clear(Calendar.MINUTE); calendarWeek.clear(Calendar.SECOND); calendarWeek.clear(Calendar.MILLISECOND); ret = calendarWeek.getTime(); return ret; } private Date computeTopOfDayDate(int days) { Date ret = null; Calendar calendarDay = Calendar.getInstance(); calendarDay.add(Calendar.DAY_OF_MONTH, days); calendarDay.set(Calendar.HOUR_OF_DAY, 0); calendarDay.clear(Calendar.MINUTE); calendarDay.clear(Calendar.SECOND); calendarDay.clear(Calendar.MILLISECOND); ret = calendarDay.getTime(); return ret; } private Date computeTopOfHourDate(int hours) { Date ret = null; Calendar calendarHour = Calendar.getInstance(); calendarHour.add(Calendar.HOUR_OF_DAY, hours); calendarHour.clear(Calendar.MINUTE); calendarHour.clear(Calendar.SECOND); calendarHour.clear(Calendar.MILLISECOND); ret = calendarHour.getTime(); return ret; } private Date computeTopOfMinuteDate(int mins) { Date ret = null; Calendar calendarMin = Calendar.getInstance(); calendarMin.add(Calendar.MINUTE, mins); calendarMin.clear(Calendar.SECOND); calendarMin.clear(Calendar.MILLISECOND); ret = calendarMin.getTime(); return ret; } private int getTimeNumeral(String rollOverPeriod, String timeLiteral) throws Exception { int ret = Integer.valueOf(rollOverPeriod.substring(0, rollOverPeriod.length() - (rollOverPeriod.length() - rollOverPeriod.indexOf(timeLiteral)))); return ret; } private String getTimeLiteral(String rollOverPeriod) throws Exception { String ret = null; if (StringUtils.isEmpty(rollOverPeriod)) { throw new Exception("empty rollover period"); } else if (rollOverPeriod.endsWith(MINUTES)) { ret = MINUTES; } else if (rollOverPeriod.endsWith(HOURS)) { ret = HOURS; } else if (rollOverPeriod.endsWith(DAYS)) { ret = DAYS; } else if (rollOverPeriod.endsWith(WEEKS)) { ret = WEEKS; } else if (rollOverPeriod.endsWith(MONTHS)) { ret = MONTHS; } else if (rollOverPeriod.endsWith(YEARS)) { ret = YEARS; } else { throw new Exception(rollOverPeriod + ": invalid rollover period"); } return ret; } public static void main(String[] args) { // Test Method for RolloverTime calculation // Set rollOverPeriod 10m,30m..,1h,2h,..1d,2d..,1w,2w..,1M,2M..1y..2y // If nothing is set for rollOverPeriod or Duration default rollOverPeriod is 1 day String rollOverPeriod = ""; RollingTimeUtil rollingTimeUtil = new RollingTimeUtil(); int duration = 86400; Date nextRollOvertime = null; try { nextRollOvertime = rollingTimeUtil.computeNextRollingTime(rollOverPeriod); } catch (Exception e) { rollOverPeriod = rollingTimeUtil.convertRolloverSecondsToRolloverPeriod(duration); System.out.println(rollOverPeriod); try { nextRollOvertime = rollingTimeUtil.computeNextRollingTime(rollOverPeriod); System.out.println(nextRollOvertime); } catch (Exception e1) { e1.printStackTrace(); } long rollOverTime = rollingTimeUtil.computeNextRollingTime(duration, null); nextRollOvertime = new Date(rollOverTime); } } }