Merge branch 'bmk/snmp/20250605/manager_start_notification/OTP-19696' into maint

Author: bmk

lib/snmp/src/manager/snmpm.erl

@@ -104,7 +104,8 @@ The module `snmpm` contains interface functions to the SNMP manager.
 -export([format_reason/1, format_reason/2]).
 
 %% Application internal export
--export([start_link/3, snmpm_start_verify/2, snmpm_start_verify/3]).
+-export([start_link/3]).
+-export([snmpm_start_verify/4, do_snmpm_start_verify/4]).
 -export([target_name/1, target_name/2]).
 
 -export_type([
@@ -393,11 +394,39 @@ to this handler.
 This function is used in conjunction with the monitor function.
 """.
 -spec notify_started(Timeout) -> Pid when
-      Timeout :: pos_integer(),
-      Pid     :: pid().
+      Timeout :: non_neg_integer(),
+      Pid     :: pid();
+                    (Args) -> Pid when
+      Args :: map(),
+      Pid  :: pid().
+
+notify_started(Timeout)
+  when is_integer(Timeout) andalso (Timeout > 0) ->
+    notify_started(#{timeout => Timeout});    
+notify_started(#{timeout := Timeout} = Args)
+  when is_integer(Timeout) andalso (Timeout > 0) ->
+    EOL      = t() + Timeout,
+    Self     = self(),
+    Verbose  = ns_get_verbose(Args),
+    TickTime = ns_get_tick_time(Args, Timeout),
+    spawn_link(?MODULE, snmpm_start_verify, [Self, Verbose, TickTime, EOL]).
+
+ns_get_verbose(Args) ->
+    case maps:get(verbose, Args, false) of
+        V when is_boolean(V) ->
+            V
+    end.
 
-notify_started(To) when is_integer(To) andalso (To > 0) ->
-    spawn_link(?MODULE, snmpm_start_verify, [self(), To]).
+ns_get_tick_time(Args, Timeout) ->
+    case maps:get(tick_time, Args, ?NOTIFY_START_TICK_TIME) of
+        %% Make sure Timeout and TickTime make sense
+        TT when is_integer(TT) andalso (TT > 0) andalso (Timeout > TT) ->
+            TT;
+        
+        %% If TickTime > Timeout, use infinity instead
+        _ ->
+            infinity
+    end.
 
 
 -doc """
@@ -411,42 +440,51 @@ cancel_notify_started(Pid) ->
     ok.
 
 -doc false.
-snmpm_start_verify(Parent, To) ->
-    ?d("starting", []),
-    snmpm_start_verify(Parent, monitor(), To).
+snmpm_start_verify(Parent, Verbose, TickTime, EOL) ->
+    put(verbose, Verbose),
+    maybe_inform("starting"),
+    do_snmpm_start_verify(Parent, monitor(), TickTime, EOL).
 
 -doc false.
-snmpm_start_verify(Parent, _Ref, To) when (To =< 0) ->
-    ?d("timeout", []),
-    unlink(Parent),
-    Parent ! {snmpm_start_timeout, self()};
-snmpm_start_verify(Parent, Ref, To) ->
-    T0 = t(),
-    receive
-	{cancel, Parent} ->
-	    ?d("cancel", []),
-	    demonitor(Ref),
-	    unlink(Parent),
-	    exit(normal);
-	{'EXIT', Parent, _} ->
-	    exit(normal);
-	{'DOWN', Ref, process, _Object, _Info} ->
-	    ?d("down", []),
-	    sleep(?NOTIFY_START_TICK_TIME),
-	    ?MODULE:snmpm_start_verify(Parent, monitor(), t(T0, To))
-    after ?NOTIFY_START_TICK_TIME ->
-	    ?d("down timeout", []),
-	    demonitor(Ref),
-	    case snmpm_server:is_started() of
-		true ->
-		    unlink(Parent),
-		    Parent ! {snmpm_started, self()};
-		_ ->
-		    ?MODULE:snmpm_start_verify(Parent, monitor(), t(T0, To))
-	    end
+do_snmpm_start_verify(Parent, Ref, TickTime, EOL) ->
+    case is_eol(EOL) of
+        true ->
+            maybe_inform("EOL - issue start-timeout"),
+            Parent ! {snmpm_start_timeout, self()},
+            unlink(Parent),
+            exit(normal);
+        false ->
+            receive
+                {cancel, Parent} ->
+                    maybe_inform("cancel"),
+                    demonitor(Ref),
+                    unlink(Parent),
+                    exit(normal);
+                {'EXIT', Parent, _} ->
+                    maybe_inform("parent death"),
+                    exit(normal);
+                {'DOWN', Ref, process, _Object, _Info} ->
+                    maybe_inform("down - not started"),
+                    sleep(TickTime),
+                    ?MODULE:do_snmpm_start_verify(Parent, monitor(),
+                                                  TickTime, EOL)
+            after TickTime ->
+                    maybe_inform("tick-timeout - check if started"),
+                    demonitor(Ref),
+                    case snmpm_server:is_started() of
+                        true ->
+                            maybe_inform("started"),
+                            unlink(Parent),
+                            Parent ! {snmpm_started, self()},
+                            exit(normal);
+                        _ ->
+                            ?MODULE:do_snmpm_start_verify(Parent, monitor(),
+                                                          TickTime, EOL)
+                    end
+            end
     end.
+                
 
-t(T0, T)  -> T - (t() - T0).
 t()       -> snmp_misc:now(ms).
 sleep(To) -> snmp_misc:sleep(To).
 
@@ -2409,8 +2447,22 @@ ensure_engine_id(Config) ->
 	    [{engine_id, DefaultEngineId} | Config]
     end.
 
+is_eol(EOL) ->
+    TS = t(),
+    (TS > EOL).
 
+maybe_inform(F) ->
+    maybe_inform(F, []).
 
+maybe_inform(F, A) ->
+    maybe_inform(get(verbose), F, A).
+
+maybe_inform(true, F, A) ->
+    error_logger:info_msg("[snmpm start notifyer ~p] " ++ F, [self()|A]);
+maybe_inform(_, _, _) ->
+    ok.
+
+    
 %% p(F) ->
 %%     p(F, []).
 

lib/snmp/test/snmp_manager_SUITE.erl

@@ -183,6 +183,7 @@ groups() ->
 
      {all,                  [], all_cases()},
      {start_and_stop_tests, [], start_and_stop_tests_cases()},
+     {notify,               [], notify_cases()},
      {misc_tests,           [], misc_tests_cases()},
      {usm_priv_aes_tests,   [], usm_priv_aes_tests_cases()},
      {user_tests,           [], user_tests_cases()},
@@ -238,6 +239,11 @@ start_and_stop_tests_cases() ->
      simple_start_and_stop3, 
      simple_start_and_monitor_crash1,
      simple_start_and_monitor_crash2, 
+     {group, notify}
+    ].
+
+notify_cases() ->
+    [
      notify_started01,
      notify_started02
     ].
@@ -1247,48 +1253,68 @@ do_notify_started01(Config) ->
 	    {config,     [{verbosity, log}, {dir, ConfDir}, {db_dir, DbDir}]}],
 
     ?IPRINT("[tc] request start notification (1)"),
-    Pid1 = snmpm:notify_started(10000),
+    NotifyPid1 = snmpm:notify_started(#{verbose   => true,
+                                        tick_time => 1000,
+                                        timeout   => 10000}),
     receive
-	{snmpm_start_timeout, Pid1} ->
-	    ?IPRINT("[tc] received expected start timeout"),
+	{snmpm_start_timeout, NotifyPid1} ->
+	    ?IPRINT("[tc] received expected start timeout (~p)", [NotifyPid1]),
 	    ok;
 	Any1 ->
-	    ?FAIL({unexpected_message, Any1})
+            ?EPRINT("received unexpected message (1): "
+                    "~n   ~p"
+                    "~n   Notify Process (~p) Info: ~p",
+                    [Any1,
+                     NotifyPid1, (catch erlang:process_info(NotifyPid1))]),
+	    ?FAIL({unexpected_message, 1, Any1})
     after 15000 ->
-	    ?FAIL({unexpected_timeout, Pid1})
+            ?EPRINT("unexpected timeout: "
+                    "~n   Notify Process (~p) Info: ~p",
+                    [NotifyPid1, (catch erlang:process_info(NotifyPid1))]),
+	    ?FAIL({unexpected_timeout, 1, NotifyPid1})
     end,
 
     ?IPRINT("[tc] request start notification (2)"),
-    Pid2 = snmpm:notify_started(10000),
+    NotifyPid2 = snmpm:notify_started(#{verbose   => true,
+                                        tick_time => 1000,
+                                        timeout   => ?NS_TIMEOUT}),
 
     ?IPRINT("[tc] start the snmpm starter"),
-    StarterPid = snmpm_starter(Opts, 5000),
+    {StarterPid, _StarterMRef} = snmpm_starter(Opts, 5000),
 
-    ?IPRINT("[tc] await the start notification"),
+    ?IPRINT("[tc] await the start notification: "
+            "~n   Notify Process:  ~p"
+            "~n   Starter Process: ~p", [NotifyPid2, StarterPid]),
     Ref = 
 	receive
-	    {snmpm_started, Pid2} ->
+	    {snmpm_started, NotifyPid2} ->
 		?IPRINT("[tc] received start notification message -> "
                         "create the monitor"),
 		snmpm:monitor();
-            {snmpm_start_timeout, StarterPid} ->
-                ?EPRINT("[tc] Start Timeout: "
-                        "~n   Starter Process (~p) Info: ~p",
-                        [StarterPid, (catch erlang:process_info(StarterPid))]),
+            {snmpm_start_timeout, NotifyPid2} ->
+                ?EPRINT("[tc] received unexpected start timeout when"
+                        "~n   Starter Process (~p) info: ~s",
+                        [StarterPid,
+                         format_process_info(StarterPid, "      ")]),
+                exit(StarterPid, kill),
                 ?FAIL(start_timeout);
 	    Any2 ->
                 ?EPRINT("[tc] Unexpected Message: "
-                        "~n   Notify Process Info:  ~p"
-                        "~n   Starter Process info: ~p",
-                        [(catch erlang:process_info(Pid2)),
-                         (catch erlang:process_info(StarterPid))]),
+                        "~n   ~p"
+                        "~n   Notify Process (~p) Info:  ~s"
+                        "~n   Starter Process (~p) info: ~s",
+                        [Any2,
+                         NotifyPid2,
+                         format_process_info(NotifyPid2, "      "),
+                         StarterPid,
+                         format_process_info(StarterPid, "      ")]),
 		?FAIL({unexpected_message, Any2})
 	after 15000 ->
                 ?EPRINT("[tc] Unexpected Start Timeout: "
-                        "~n   Notify Process Info:  ~p"
-                        "~n   Starter Process info: ~p",
-                        [(catch erlang:process_info(Pid2)),
-                         (catch erlang:process_info(StarterPid))]),
+                        "~n   Notify Process (~p) Info:  ~p"
+                        "~n   Starter Process (~p) info: ~p",
+                        [NotifyPid2, (catch erlang:process_info(NotifyPid2)),
+                         StarterPid, (catch erlang:process_info(StarterPid))]),
 		?FAIL(unexpected_start_timeout)
 	end,
 
@@ -1319,10 +1345,51 @@ do_notify_started01(Config) ->
     ?IPRINT("[tc] end"),
     ok.
 
+format_process_info(P, Indent) when is_pid(P) andalso is_list(Indent) ->
+    try
+        begin
+            CurrentFunction   = pi(P, current_function),
+            CurrentStackTrace = pi(P, current_stacktrace),
+            Reductions        = pi(P, reductions),
+            Memory            = pi(P, memory),
+            HeapSize          = pi(P, heap_size),
+            MaxHeapSize       = pi(P, max_heap_size),
+            TotHeapSize       = pi(P, total_heap_size),
+            Status            = pi(P, status),
+            ?F("~n"
+               "~sCurrent Function:   ~p~n"
+               "~sCurrent StackTrace: ~p~n"
+               "~sReductions:         ~p~n"
+               "~sMemory:             ~p~n"
+               "~sHeapSize:           ~p~n"
+               "~sMax Heap Size:      ~p~n"
+               "~sTotal Heap Size:    ~p~n"
+               "~sStatus:             ~p~n",
+               [Indent, CurrentFunction,
+                Indent, CurrentStackTrace,
+                Indent, Reductions,
+                Indent, Memory,
+                Indent, HeapSize,
+                Indent, MaxHeapSize,
+                Indent, TotHeapSize,
+                Indent, Status])
+        end
+    catch
+        _:_:_ ->
+            "-"
+    end.
 
+pi(Pid, Key) ->
+    case ?PI(Pid, Key) of
+        undefined ->
+            throw(no_process);
+        Value ->
+            Value
+    end.
+    
 snmpm_starter(Opts, To) ->
     Parent = self(),
-    spawn(
+    spawn_monitor(
       fun() ->
               ?IPRINT("[snmpm-starter] wait ~w msec", [To]),
 	      ?SLEEP(To),
@@ -1473,7 +1540,10 @@ ns02_client(Parent, N) when is_pid(Parent) ->
     put(tname, ns02_client),
     ?IPRINT("starting"),
     ns02_client_loop(Parent, 
-                     dummy, snmpm:notify_started(?NS_TIMEOUT),
+                     dummy,
+                     snmpm:notify_started(#{verbose   => true,
+                                            tick_time => 1000,
+                                            timeout   => ?NS_TIMEOUT}),
                      snmp_misc:now(ms), undefined,
                      N).
 
@@ -1514,7 +1584,10 @@ ns02_client_loop(Parent, Ref, Pid, Begin, End, N) ->
                     "~n   Obj:    ~p"
                     "~n   Reason: ~p", [N, Obj, Reason]),
 	    ns02_client_loop(Parent,
-                             dummy, snmpm:notify_started(?NS_TIMEOUT),
+                             dummy,
+                             snmpm:notify_started(#{verbose   => true,
+                                                    tick_time => 1000,
+                                                    timeout   => ?NS_TIMEOUT}),
                              Begin, snmp_misc:now(ms),
                              N-1)
     end.

lib/snmp/test/snmp_test_lib.erl

@@ -41,7 +41,7 @@
 	 replace_config/3, set_config/3, get_config/2, get_config/3]).
 -export([fail/3, skip/3]).
 -export([hours/1, minutes/1, seconds/1, sleep/1]).
--export([flush_mqueue/0, mqueue/0, mqueue/1, trap_exit/0, trap_exit/1]).
+-export([pi/2, flush_mqueue/0, mqueue/0, mqueue/1, trap_exit/0, trap_exit/1]).
 -export([ping/1, local_nodes/0, nodes_on/1]).
 -export([is_app_running/1,
 	 is_crypto_running/0, is_mnesia_running/0, is_snmp_running/0,

lib/snmp/test/snmp_test_lib.hrl

@@ -98,6 +98,8 @@
                         catch _:_:_ ->
                                 {not_running, __P__}
                         end).
+-define(PI(K),          ?PI(self(), K)).
+-define(PI(P, K),       ?LIB:pi((P), (K))).
 
 
 %% - Node utility macros -