Make it possible to use raw telnet logs in parallel test case groups

1 files changed, 50 insertions, 34 deletions

diff --git a/lib/common_test/src/ct_conn_log_h.erl b/lib/common_test/src/ct_conn_log_h.erl
index 6e0e0baab2..2b83ff1abb 100644
--- a/lib/common_test/src/ct_conn_log_h.erl
+++ b/lib/common_test/src/ct_conn_log_h.erl
@@ -30,79 +30,90 @@
 	 handle_event/2, handle_call/2, handle_info/2,
 	 terminate/2]).
 
--record(state, {group_leader,logs=[]}).
+-record(state, {logs=[], default_gl}).
 
 -define(WIDTH,80).
 
 %%%-----------------------------------------------------------------
 %%% Callbacks
-init({GL,Logs}) ->
-    open_files(Logs,#state{group_leader=GL}).
+init({GL,ConnLogs}) ->
+    open_files(GL,ConnLogs,#state{default_gl=GL}).
 
-open_files([{ConnMod,{LogType,Logs}}|T],State) ->
-    case do_open_files(Logs,[]) of
+open_files(GL,[{ConnMod,{LogType,ConnLogs}}|T],State) ->
+    case do_open_files(GL,ConnLogs,[]) of
 	{ok,Fds} ->
-	    open_files(T,State#state{logs=[{ConnMod,{LogType,Fds}} |
-					   State#state.logs]});
+	    open_files(GL,T,State#state{logs=[{GL,[{ConnMod,{LogType,Fds}}]} |
+					      State#state.logs]});
 	Error ->
 	    Error
     end;
-open_files([],State) ->
+open_files(_GL,[],State) ->
     {ok,State}.
 
-
-do_open_files([{Tag,File}|Logs],Acc) ->
+do_open_files(GL,[{Tag,File}|ConnLogs],Acc) ->
     case file:open(File, [write,append,{encoding,utf8}]) of
 	{ok,Fd} ->
-	    do_open_files(Logs,[{Tag,Fd}|Acc]);
+	    do_open_files(GL,ConnLogs,[{Tag,Fd}|Acc]);
 	{error,Reason} ->
 	    {error,{could_not_open_log,File,Reason}}
     end;
-do_open_files([],Acc) ->
+do_open_files(_GL,[],Acc) ->
     {ok,lists:reverse(Acc)}.
 
+handle_event({info_report,_,{From,update,{GL,ConnLogs}}},
+	     State) when node(GL) == node() ->
+
+    %%! --- Tue Jan 28 12:18:50 2014 --- peppe was here!
+    io:format(user, "!!! ADDING NEW LOGS FOR ~p~n", [GL]),
+
+    open_files(GL,ConnLogs,#state{}),
+    From ! {updated,GL},
+    {ok, State};
 handle_event({_Type, GL, _Msg}, State) when node(GL) /= node() ->
     {ok, State};
-handle_event({_Type,_GL,{Pid,{ct_connection,Mod,Action,ConnName},Report}},
+handle_event({_Type,GL,{Pid,{ct_connection,Mod,Action,ConnName},Report}},
 	     State) ->
     Info = conn_info(Pid,#conn_log{name=ConnName,action=Action,module=Mod}),
-    write_report(now(),Info,Report,State),
+    write_report(now(),Info,Report,GL,State),
     {ok, State};
-handle_event({_Type,_GL,{Pid,Info=#conn_log{},Report}},State) ->
-    write_report(now(),conn_info(Pid,Info),Report,State),
+handle_event({_Type,GL,{Pid,Info=#conn_log{},Report}}, State) ->
+    write_report(now(),conn_info(Pid,Info),Report,GL,State),
     {ok, State};
-handle_event({error_report,_,{Pid,_,[{ct_connection,ConnName}|R]}},State) ->
+handle_event({error_report,GL,{Pid,_,[{ct_connection,ConnName}|R]}}, State) ->
     %% Error reports from connection
-    write_error(now(),conn_info(Pid,#conn_log{name=ConnName}),R,State),
+    write_error(now(),conn_info(Pid,#conn_log{name=ConnName}),R,GL,State),
     {ok, State};
-handle_event(_, State) ->
+handle_event(_What, State) ->
     {ok, State}.
 
-handle_info(_, State) ->
+handle_info(_What, State) ->
     {ok, State}.
 
 handle_call(_Query, State) ->
     {ok, {error, bad_query}, State}.
 
 terminate(_,#state{logs=Logs}) ->
-    [file:close(Fd) || {_,{_,Fds}} <- Logs, {_,Fd} <- Fds],
+    lists:foreach(
+      fun({_GL,ConnLogs}) ->
+	      [file:close(Fd) || {_,{_,Fds}} <- ConnLogs, {_,Fd} <- Fds]
+      end, Logs),
     ok.
 
 
 %%%-----------------------------------------------------------------
 %%% Writing reports
-write_report(_Time,#conn_log{header=false,module=ConnMod}=Info,Data,State) ->
-    {LogType,Fd} = get_log(Info,State),
+write_report(_Time,#conn_log{header=false,module=ConnMod}=Info,Data,GL,State) ->
+    {LogType,Fd} = get_log(Info,GL,State),
     io:format(Fd,"~n~ts",[format_data(ConnMod,LogType,Data)]);
 
-write_report(Time,#conn_log{module=ConnMod}=Info,Data,State) ->
-    {LogType,Fd} = get_log(Info,State),
+write_report(Time,#conn_log{module=ConnMod}=Info,Data,GL,State) ->
+    {LogType,Fd} = get_log(Info,GL,State),
     io:format(Fd,"~n~ts~ts~ts",[format_head(ConnMod,LogType,Time),
 				format_title(LogType,Info),
 				format_data(ConnMod,LogType,Data)]).
 
-write_error(Time,#conn_log{module=ConnMod}=Info,Report,State) ->
-    case get_log(Info,State) of
+write_error(Time,#conn_log{module=ConnMod}=Info,Report,GL,State) ->
+    case get_log(Info,GL,State) of
 	{html,_} ->
 	    %% The error will anyway be written in the html log by the
 	    %% sasl error handler, so don't write it again.
@@ -114,14 +125,19 @@ write_error(Time,#conn_log{module=ConnMod}=Info,Report,State) ->
 		       format_error(LogType,Report)])
     end.
 
-get_log(Info,State) ->
-    case proplists:get_value(Info#conn_log.module,State#state.logs) of
-	{html,_} ->
-	    {html,State#state.group_leader};
-	{LogType,Fds} ->
-	    {LogType,get_fd(Info,Fds)};
+get_log(Info,GL,State) ->
+    case proplists:get_value(GL, State#state.logs) of
 	undefined ->
-	    {html,State#state.group_leader}
+	    {html,State#state.default_gl};
+	ConnLogs ->
+	    case proplists:get_value(Info#conn_log.module,ConnLogs) of
+		{html,_} ->
+		    {html,GL};
+		{LogType,Fds} ->
+		    {LogType,get_fd(Info,Fds)};
+		undefined ->
+		    {html,GL}
+	    end
     end.
 
 get_fd(#conn_log{name=undefined},Fds) ->