From cf52e343fed1add044562835d82c1f9b586f58ec Mon Sep 17 00:00:00 2001
From: SisMaker <1713699517@qq.com>
Date: Wed, 10 Mar 2021 20:15:10 +0800
Subject: [PATCH] =?UTF-8?q?ft:=20date=E8=BD=AC=E6=8D=A2=E5=87=BD=E6=95=B0?=
 =?UTF-8?q?=E4=BF=AE=E6=94=B9=20=E8=BD=AC=E6=8D=A2=E5=87=BD=E6=95=B0?=
 =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/backend/rumBackendFile.erl |   2 +-
 src/crashLog/rumCrashLog.erl   |   2 +-
 src/utils/rumUtil.erl          | 146 ++++++++++++++++-----------------
 3 files changed, 74 insertions(+), 76 deletions(-)

diff --git a/src/backend/rumBackendFile.erl b/src/backend/rumBackendFile.erl
index e43de1e..2cf8c9c 100644
--- a/src/backend/rumBackendFile.erl
+++ b/src/backend/rumBackendFile.erl
@@ -446,7 +446,7 @@ validate_logfile_proplist([Other | _Tail], _Acc) ->
 schedule_rotation(_, undefined) ->
    ok;
 schedule_rotation(Name, Date) ->
-   erlang:send_after(rumUtil:calcNextRotate(Date) * 1000, self(), {mRotate, Name}),
+   erlang:send_after(rumUtil:calcNextRotateMs(Date), self(), {mRotate, Name}),
    ok.
 
 close_file(#state{fd = undefined} = State) ->
diff --git a/src/crashLog/rumCrashLog.erl b/src/crashLog/rumCrashLog.erl
index 281558c..9ff9b61 100644
--- a/src/crashLog/rumCrashLog.erl
+++ b/src/crashLog/rumCrashLog.erl
@@ -92,7 +92,7 @@ code_change(_OldVsn, State, _Extra) ->
 
 scheduleRotation(undefined) -> ok;
 scheduleRotation(Date) ->
-   erlang:send_after(rumUtil:calcNextRotate(Date) * 1000, self(), mRotate),
+   erlang:send_after(rumUtil:calcNextRotateMs(Date), self(), mRotate),
    ok.
 
 %% ===== Begin code lifted from riak_err =====
diff --git a/src/utils/rumUtil.erl b/src/utils/rumUtil.erl
index 2866ab4..07af9df 100644
--- a/src/utils/rumUtil.erl
+++ b/src/utils/rumUtil.erl
@@ -15,9 +15,9 @@
    , msToBinStr/0
    , msToBinStr/1
    , parseRotateSpec/1
-   , calcNextRotate/1
-   , calcNextRotate/2
-   , calcNextRotateT/2
+   , calcNextRotateMs/1
+   , calcNextRotateMs/2
+   , calcNextRotateDt/2
    , validate_trace/1
    , check_traces/4
    , is_loggable/3
@@ -211,7 +211,7 @@ parseRotateHourSpec([], DayOrMonth, Hour, Minute) ->
    {DayOrMonth, Hour, Minute};
 parseRotateHourSpec([$H, M1, M2], DayOrMonth, Hour, _Minute) when M1 >= $0, M1 =< $9, M2 >= $0, M2 =< $9 ->
    Min = list_to_integer([M1, M2]),
-   ?IIF(Hour >= 0 andalso Hour =< 59, {DayOrMonth, Hour, Min}, {error, invalid_date_spec});
+   ?IIF(Min >= 0 andalso Min =< 59, {DayOrMonth, Hour, Min}, {error, invalid_date_spec});
 parseRotateHourSpec([$H, M], DayOrMonth, Hour, _Minute) when M >= $0, M =< $9 ->
    {DayOrMonth, Hour, M - $0};
 parseRotateHourSpec(_, _DayOrMonth, _Hour, _Minute) ->
@@ -221,7 +221,7 @@ parseRotateHourSpec(_, _DayOrMonth, _Hour, _Minute) ->
 parseRotateDaySpec([], DayOrMonth, Hour, Minute) ->
    {DayOrMonth, Hour, Minute};
 parseRotateDaySpec([$D, D1, D2 | T], DayOrMonth, _Hour, _Minute) when D1 > $0, D1 < $9, D2 > $0, D2 < $9 ->
-   Day = list_to_integer([D1, D1]),
+   Day = list_to_integer([D1, D2]),
    ?IIF(Day >= 0 andalso Day =< 23, parseRotateHourSpec(T, DayOrMonth, Day, 0), {error, invalid_date_spec});
 parseRotateDaySpec([$D, D | T], DayOrMonth, _Hour, _Minute) when D >= $0, D =< $9 ->
    parseRotateHourSpec(T, DayOrMonth, D - $0, 0);
@@ -248,21 +248,22 @@ parseRotateSpec(Spec) ->
       {error, _} = ErrRet ->
          ErrRet;
       {undefined, undefined, undefined} ->
-         {error, undefined};
+         {error, invalid_date_spec};
       STuple ->
          {ok, STuple}
    end.
 
-calcNextRotate(Spec) ->
+calcNextRotateMs(Spec) ->
    {Date, Time} = NowDataTime = erlang:localtime(),
    NextTime = calcNextRotate(Spec, Date, Time),
    (rumTime:lDateTimeToSec(NextTime) - rumTime:lDateTimeToSec(NowDataTime)) * 1000.
-calcNextRotate(Spec, NowDataTime) ->
+
+calcNextRotateMs(Spec, NowDataTime) ->
    {Date, Time} = NowDataTime,
    NextTime = calcNextRotate(Spec, Date, Time),
    (rumTime:lDateTimeToSec(NextTime) - rumTime:lDateTimeToSec(NowDataTime)) * 1000.
 
-calcNextRotateT(Spec, NowDataTime) ->
+calcNextRotateDt(Spec, NowDataTime) ->
    {Date, Time} = NowDataTime,
    calcNextRotate(Spec, Date, Time).
 
@@ -290,16 +291,16 @@ calcNextRotate(Spec, CurDate, CurTime) ->
                rumTime:secToLDateTime(NexSec)
          end;
       {{day, SDay}, SHour, SMinute} ->
-         CurDay = rumTime:weekDay(CurDate),
+         CurWeekDay = rumTime:weekDay(CurDate),
          if
-            CurDay < SDay ->
+            CurWeekDay < SDay ->
                %% rotation is this week
-               DiffDays = SDay - CurDay,
+               DiffDays = SDay - CurWeekDay,
                NexSec = rumTime:lDateTimeToSec({CurDate, {SHour, SMinute, 0}}) + (86400 * DiffDays),
                rumTime:secToLDateTime(NexSec);
-            CurDay > SDay ->
+            CurWeekDay > SDay ->
                %% rotation is next week
-               DiffDays = ((7 - CurDay) + SDay),
+               DiffDays = ((7 - CurWeekDay) + SDay),
                NexSec = rumTime:lDateTimeToSec({CurDate, {SHour, SMinute, 0}}) + (86400 * DiffDays),
                rumTime:secToLDateTime(NexSec);
             true ->
@@ -340,8 +341,8 @@ calcNextRotate(Spec, CurDate, CurTime) ->
                {{CurYear, CurMonth, SDate}, {SHour, SMinute, 0}};
             CurDay > SDate ->
                %% rotation is next month day
-               LastDay = rumTime:monthDay(CurYear, CurMonth),
-               NexSec = rumTime:lDateTimeToSec({{CurYear, CurMonth, LastDay}, {23, 59, 59}}) + 1,
+               CurMonthDay = rumTime:monthDay(CurYear, CurMonth),
+               NexSec = rumTime:lDateTimeToSec({{CurYear, CurMonth, CurMonthDay}, {23, 59, 59}}) + 1,
                {NewNDate, _NewNTime} = rumTime:secToLDateTime(NexSec),
                {NewNYear, NewNMonth, _} = NewNDate,
                {{NewNYear, NewNMonth, SDate}, {SHour, SMinute, 0}};
@@ -352,8 +353,8 @@ calcNextRotate(Spec, CurDate, CurTime) ->
                      {CurDate, {SHour, SMinute, 0}};
                   _ ->
                      %% rotation is next month day
-                     LastDay = rumTime:monthDay(CurYear, CurMonth),
-                     NexSec = rumTime:lDateTimeToSec({{CurYear, CurMonth, LastDay}, {23, 59, 59}}) + 1,
+                     CurMonthDay = rumTime:monthDay(CurYear, CurMonth),
+                     NexSec = rumTime:lDateTimeToSec({{CurYear, CurMonth, CurMonthDay}, {23, 59, 59}}) + 1,
                      {NewNDate, _NewNTime} = rumTime:secToLDateTime(NexSec),
                      {NewNYear, NewNMonth, _} = NewNDate,
                      {{NewNYear, NewNMonth, SDate}, {SHour, SMinute, 0}}
@@ -631,94 +632,91 @@ get_env(Key, Def) ->
    end.
 
 -ifdef(TEST).
-
 parse_test() ->
-   ?assertEqual({ok, [{minute, 0}]}, parseRotateDateSpec("$H0")),
-   ?assertEqual({ok, [{minute, 59}]}, parseRotateDateSpec("$H59")),
-   ?assertEqual({ok, [{hour, 0}]}, parseRotateDateSpec("$D0")),
-   ?assertEqual({ok, [{hour, 23}]}, parseRotateDateSpec("$D23")),
-   ?assertEqual({ok, [{day, 0}, {hour, 23}]}, parseRotateDateSpec("$W0D23")),
-   ?assertEqual({ok, [{day, 5}, {hour, 16}]}, parseRotateDateSpec("$W5D16")),
-   ?assertEqual({ok, [{day, 0}, {hour, 12}, {minute, 30}]}, parseRotateDateSpec("$W0D12H30")),
-   ?assertEqual({ok, [{date, 1}, {hour, 0}]}, parseRotateDateSpec("$M1D0")),
-   ?assertEqual({ok, [{date, 5}, {hour, 6}]}, parseRotateDateSpec("$M5D6")),
-   ?assertEqual({ok, [{date, 5}, {hour, 0}]}, parseRotateDateSpec("$M5")),
-   ?assertEqual({ok, [{date, 31}, {hour, 0}]}, parseRotateDateSpec("$M31")),
-   ?assertEqual({ok, [{date, 31}, {hour, 1}]}, parseRotateDateSpec("$M31D1")),
-   ?assertEqual({ok, [{date, last}, {hour, 0}]}, parseRotateDateSpec("$ML")),
-   ?assertEqual({ok, [{date, last}, {hour, 0}]}, parseRotateDateSpec("$Ml")),
-   ?assertEqual({ok, [{day, 5}, {hour, 0}]}, parseRotateDateSpec("$W5")),
+   ?assertEqual({ok, {undefined, undefined, 0}}, rumUtil:parseRotateSpec("$H0")),
+   ?assertEqual({ok, {undefined, undefined, 59}}, rumUtil:parseRotateSpec("$H59")),
+   ?assertEqual({ok, {undefined, 0, 0}}, rumUtil:parseRotateSpec("$D0")),
+   ?assertEqual({ok, {undefined, 23, 0}}, rumUtil:parseRotateSpec("$D23")),
+   ?assertEqual({ok, {{day, 7}, 23, 0}}, rumUtil:parseRotateSpec("$W7D23")),
+   ?assertEqual({ok, {{day, 5}, 16, 0}}, rumUtil:parseRotateSpec("$W5D16")),
+   ?assertEqual({ok, {{day, 7}, 12, 30}}, rumUtil:parseRotateSpec("$W7D12H30")),
+   ?assertEqual({ok, {{date, 1}, 0, 0}}, rumUtil:parseRotateSpec("$M1D0")),
+   ?assertEqual({ok, {{date, 5}, 6, 0}}, rumUtil:parseRotateSpec("$M5D6")),
+   ?assertEqual({ok, {{date, 5}, 0, 0}}, rumUtil:parseRotateSpec("$M5")),
+   ?assertEqual({ok, {{date, 31}, 0, 0}}, rumUtil:parseRotateSpec("$M31")),
+   ?assertEqual({ok, {{date, 31}, 1, 0}}, rumUtil:parseRotateSpec("$M31D1")),
+   ?assertEqual({ok, {{date, last}, 0, 0}}, rumUtil:parseRotateSpec("$ML")),
+   ?assertEqual({ok, {{date, last}, 0, 0}}, rumUtil:parseRotateSpec("$Ml")),
+   ?assertEqual({ok, {{day, 5}, 0, 0}}, rumUtil:parseRotateSpec("$W5")),
+   ?assertEqual({ok, {{date, 5}, 12, 36}}, rumUtil:parseRotateSpec("$M5D12H36")),
    ok.
 
 parse_fail_test() ->
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$H")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$H60")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$D")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$D24")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$W7")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$W7D1")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$M32")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$M32D1")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$D15M5")),
-   ?assertEqual({error, invalid_date_spec}, parseRotateDateSpec("$M5W5")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$H")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$H60")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$D")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$D24")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$W0")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$W0D1")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$M32")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$M32D1")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$D15M5")),
+   ?assertEqual({error, invalid_date_spec}, rumUtil:parseRotateSpec("$M5W5")),
    ok.
 
 rotation_calculation_test() ->
    ?assertMatch({{2000, 1, 1}, {13, 0, 0}},
-      calcNextRotate([{minute, 0}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({undefined, undefined, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 1}, {12, 45, 0}},
-      calcNextRotate([{minute, 45}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({undefined, undefined, 45}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 2}, {0, 0, 0}},
-      calcNextRotate([{minute, 0}], {{2000, 1, 1}, {23, 45, 43}})),
+      rumUtil:calcNextRotateDt({undefined, undefined, 0}, {{2000, 1, 1}, {23, 45, 43}})),
    ?assertMatch({{2000, 1, 2}, {0, 0, 0}},
-      calcNextRotate([{hour, 0}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({undefined, 0, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 1}, {16, 0, 0}},
-      calcNextRotate([{hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({undefined, 16, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 2}, {12, 0, 0}},
-      calcNextRotate([{hour, 12}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({undefined, 12, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
-      calcNextRotate([{date, 1}, {hour, 12}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, 1}, 12, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
-      calcNextRotate([{date, 1}, {hour, 12}], {{2000, 1, 15}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, 1}, 12, 0}, {{2000, 1, 15}, {12, 34, 43}})),
    ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
-      calcNextRotate([{date, 1}, {hour, 12}], {{2000, 1, 2}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, 1}, 12, 0}, {{2000, 1, 2}, {12, 34, 43}})),
    ?assertMatch({{2000, 2, 1}, {12, 0, 0}},
-      calcNextRotate([{date, 1}, {hour, 12}], {{2000, 1, 31}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, 1}, 12, 0}, {{2000, 1, 31}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 1}, {16, 0, 0}},
-      calcNextRotate([{date, 1}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, 1}, 16, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 15}, {16, 0, 0}},
-      calcNextRotate([{date, 15}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, 15}, 16, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 31}, {16, 0, 0}},
-      calcNextRotate([{date, last}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, last}, 16, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 31}, {16, 0, 0}},
-      calcNextRotate([{date, last}, {hour, 16}], {{2000, 1, 31}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, last}, 16, 0}, {{2000, 1, 31}, {12, 34, 43}})),
    ?assertMatch({{2000, 2, 29}, {16, 0, 0}},
-      calcNextRotate([{date, last}, {hour, 16}], {{2000, 1, 31}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{date, last}, 16, 0}, {{2000, 1, 31}, {17, 34, 43}})),
    ?assertMatch({{2001, 2, 28}, {16, 0, 0}},
-      calcNextRotate([{date, last}, {hour, 16}], {{2001, 1, 31}, {17, 34, 43}})),
-
+      rumUtil:calcNextRotateDt({{date, last}, 16, 0}, {{2001, 1, 31}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 1}, {16, 0, 0}},
-      calcNextRotate([{day, 6}, {hour, 16}], {{2000, 1, 1}, {12, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 6}, 16, 0}, {{2000, 1, 1}, {12, 34, 43}})),
    ?assertMatch({{2000, 1, 8}, {16, 0, 0}},
-      calcNextRotate([{day, 6}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 6}, 16, 0}, {{2000, 1, 1}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 7}, {16, 0, 0}},
-      calcNextRotate([{day, 5}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 5}, 16, 0}, {{2000, 1, 1}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 3}, {16, 0, 0}},
-      calcNextRotate([{day, 1}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 1}, 16, 0}, {{2000, 1, 1}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 2}, {16, 0, 0}},
-      calcNextRotate([{day, 0}, {hour, 16}], {{2000, 1, 1}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 7}, 16, 0}, {{2000, 1, 1}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 9}, {16, 0, 0}},
-      calcNextRotate([{day, 0}, {hour, 16}], {{2000, 1, 2}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 7}, 16, 0}, {{2000, 1, 2}, {17, 34, 43}})),
    ?assertMatch({{2000, 2, 3}, {16, 0, 0}},
-      calcNextRotate([{day, 4}, {hour, 16}], {{2000, 1, 29}, {17, 34, 43}})),
-
+      rumUtil:calcNextRotateDt({{day, 4}, 16, 0}, {{2000, 1, 29}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 7}, {16, 0, 0}},
-      calcNextRotate([{day, 5}, {hour, 16}], {{2000, 1, 3}, {17, 34, 43}})),
-
+      rumUtil:calcNextRotateDt({{day, 5}, 16, 0}, {{2000, 1, 3}, {17, 34, 43}})),
    ?assertMatch({{2000, 1, 3}, {16, 0, 0}},
-      calcNextRotate([{day, 1}, {hour, 16}], {{1999, 12, 28}, {17, 34, 43}})),
+      rumUtil:calcNextRotateDt({{day, 1}, 16, 0}, {{1999, 12, 28}, {17, 34, 43}})),
    ok.
 
 check_trace_test() ->