mirror of
https://github.com/correl/rebar.git
synced 2024-11-23 19:19:54 +00:00
ba466e2d38
Using code:set_path/1 with very large paths is very slow on larger projects. On my mid-sized project, it seems to take around .4s per call. Emulating the call with direct path removal (using code:del_path/1) seems to be quite a lot faster.
675 lines
25 KiB
Erlang
675 lines
25 KiB
Erlang
%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
|
|
%% ex: ts=4 sw=4 et
|
|
%% -------------------------------------------------------------------
|
|
%%
|
|
%% rebar: Erlang Build Tools
|
|
%%
|
|
%% Copyright (c) 2009, 2010 Dave Smith (dizzyd@dizzyd.com)
|
|
%%
|
|
%% Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
%% of this software and associated documentation files (the "Software"), to deal
|
|
%% in the Software without restriction, including without limitation the rights
|
|
%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
%% copies of the Software, and to permit persons to whom the Software is
|
|
%% furnished to do so, subject to the following conditions:
|
|
%%
|
|
%% The above copyright notice and this permission notice shall be included in
|
|
%% all copies or substantial portions of the Software.
|
|
%%
|
|
%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
%% THE SOFTWARE.
|
|
%% -------------------------------------------------------------------
|
|
%% @author Dave Smith <dizzyd@dizzyd.com>
|
|
%% @doc rebar_eunit supports the following commands:
|
|
%% <ul>
|
|
%% <li>eunit - runs eunit tests</li>
|
|
%% <li>clean - remove ?EUNIT_DIR directory</li>
|
|
%% <li>reset_after_eunit::boolean() - default = true.
|
|
%% If true, try to "reset" VM state to approximate state prior to
|
|
%% running the EUnit tests:
|
|
%% <ul>
|
|
%% <li>Stop net_kernel if it was started</li>
|
|
%% <li>Stop OTP applications not running before EUnit tests were run</li>
|
|
%% <li>Kill processes not running before EUnit tests were run</li>
|
|
%% <li>Reset OTP application environment variables</li>
|
|
%% </ul>
|
|
%% </li>
|
|
%% </ul>
|
|
%% The following Global options are supported:
|
|
%% <ul>
|
|
%% <li>verbose=1 - show extra output from the eunit test</li>
|
|
%% <li>
|
|
%% suites="foo,bar" - runs tests in foo.erl, test/foo_tests.erl and
|
|
%% tests in bar.erl, test/bar_tests.erl
|
|
%% </li>
|
|
%% <li>
|
|
%% suites="foo,bar" tests="baz"- runs first test with name starting
|
|
%% with 'baz' in foo.erl, test/foo_tests.erl and tests in bar.erl,
|
|
%% test/bar_tests.erl
|
|
%% </li>
|
|
%% <li>
|
|
%% tests="baz"- For every existing suite, run the first test whose
|
|
%% name starts with bar and, if no such test exists, run the test
|
|
%% whose name starts with bar in the suite's _tests module
|
|
%% </li>
|
|
%% </ul>
|
|
%% Additionally, for projects that have separate folders for the core
|
|
%% implementation, and for the unit tests, then the following
|
|
%% <code>rebar.config</code> option can be provided:
|
|
%% <code>{eunit_compile_opts, [{src_dirs, ["src", "dir"]}]}.</code>.
|
|
%% @copyright 2009, 2010 Dave Smith
|
|
%% -------------------------------------------------------------------
|
|
-module(rebar_eunit).
|
|
|
|
-export([eunit/2,
|
|
clean/2]).
|
|
|
|
%% for internal use only
|
|
-export([info/2]).
|
|
|
|
-include("rebar.hrl").
|
|
|
|
-define(EUNIT_DIR, ".eunit").
|
|
|
|
%% ===================================================================
|
|
%% Public API
|
|
%% ===================================================================
|
|
|
|
eunit(Config, _AppFile) ->
|
|
ok = ensure_dirs(),
|
|
%% Save code path
|
|
CodePath = setup_code_path(),
|
|
CompileOnly = rebar_config:get_global(Config, compile_only, false),
|
|
{ok, SrcErls} = rebar_erlc_compiler:test_compile(Config, "eunit",
|
|
?EUNIT_DIR),
|
|
case CompileOnly of
|
|
"true" ->
|
|
true = rebar_utils:cleanup_code_path(CodePath),
|
|
?CONSOLE("Compiled modules for eunit~n", []);
|
|
false ->
|
|
run_eunit(Config, CodePath, SrcErls)
|
|
end.
|
|
|
|
clean(_Config, _File) ->
|
|
rebar_file_utils:rm_rf(?EUNIT_DIR).
|
|
|
|
%% ===================================================================
|
|
%% Internal functions
|
|
%% ===================================================================
|
|
|
|
info(help, eunit) ->
|
|
info_help("Run eunit tests");
|
|
info(help, clean) ->
|
|
Description = ?FMT("Delete eunit test dir (~s)", [?EUNIT_DIR]),
|
|
info_help(Description).
|
|
|
|
info_help(Description) ->
|
|
?CONSOLE(
|
|
"~s.~n"
|
|
"~n"
|
|
"Valid rebar.config options:~n"
|
|
" ~p~n"
|
|
" ~p~n"
|
|
" ~p~n"
|
|
" ~p~n"
|
|
" ~p~n"
|
|
" ~p~n"
|
|
"Valid command line options:~n"
|
|
" suite[s]=\"foo,bar\" (Run tests in foo.erl, test/foo_tests.erl and~n"
|
|
" tests in bar.erl, test/bar_tests.erl)~n"
|
|
" test[s]=\"baz\" (For every existing suite, run the first test whose~n"
|
|
" name starts with bar and, if no such test exists,~n"
|
|
" run the test whose name starts with bar in the~n"
|
|
" suite's _tests module)~n"
|
|
" random_suite_order=true (Run tests in random order)~n"
|
|
" random_suite_order=Seed (Run tests in random order,~n"
|
|
" with the PRNG seeded with Seed)~n"
|
|
" compile_only=true (Compile but do not run tests)",
|
|
[
|
|
Description,
|
|
{eunit_opts, []},
|
|
{eunit_compile_opts, []},
|
|
{eunit_first_files, []},
|
|
{cover_enabled, false},
|
|
{cover_print_enabled, false},
|
|
{cover_export_enabled, false}
|
|
]).
|
|
|
|
run_eunit(Config, CodePath, SrcErls) ->
|
|
%% Build a list of all the .beams in ?EUNIT_DIR -- use this for
|
|
%% cover and eunit testing. Normally you can just tell cover
|
|
%% and/or eunit to scan the directory for you, but eunit does a
|
|
%% code:purge in conjunction with that scan and causes any cover
|
|
%% compilation info to be lost.
|
|
|
|
AllBeamFiles = rebar_utils:beams(?EUNIT_DIR),
|
|
{BeamFiles, TestBeamFiles} =
|
|
lists:partition(fun(N) -> string:str(N, "_tests.beam") =:= 0 end,
|
|
AllBeamFiles),
|
|
OtherBeamFiles = TestBeamFiles --
|
|
[filename:rootname(N) ++ "_tests.beam" || N <- AllBeamFiles],
|
|
ModuleBeamFiles = randomize_suites(Config, BeamFiles ++ OtherBeamFiles),
|
|
|
|
%% Get matching tests and modules
|
|
AllModules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- AllBeamFiles],
|
|
{Tests, FilteredModules} =
|
|
get_tests_and_modules(Config, ModuleBeamFiles, AllModules),
|
|
|
|
SrcModules = [rebar_utils:erl_to_mod(M) || M <- SrcErls],
|
|
|
|
{ok, CoverLog} = rebar_cover_utils:init(Config, ModuleBeamFiles,
|
|
eunit_dir()),
|
|
|
|
StatusBefore = status_before_eunit(),
|
|
EunitResult = perform_eunit(Config, Tests),
|
|
|
|
rebar_cover_utils:perform_cover(Config, FilteredModules, SrcModules,
|
|
eunit_dir()),
|
|
rebar_cover_utils:close(CoverLog),
|
|
|
|
case proplists:get_value(reset_after_eunit, get_eunit_opts(Config),
|
|
true) of
|
|
true ->
|
|
reset_after_eunit(StatusBefore);
|
|
false ->
|
|
ok
|
|
end,
|
|
|
|
%% Stop cover to clean the cover_server state. This is important if we want
|
|
%% eunit+cover to not slow down when analyzing many Erlang modules.
|
|
ok = rebar_cover_utils:exit(),
|
|
|
|
case EunitResult of
|
|
ok ->
|
|
ok;
|
|
_ ->
|
|
?ABORT("One or more eunit tests failed.~n", [])
|
|
end,
|
|
|
|
%% Restore code path
|
|
true = rebar_utils:cleanup_code_path(CodePath),
|
|
ok.
|
|
|
|
ensure_dirs() ->
|
|
%% Make sure ?EUNIT_DIR/ and ebin/ directory exists (append dummy module)
|
|
ok = filelib:ensure_dir(filename:join(eunit_dir(), "dummy")),
|
|
ok = filelib:ensure_dir(filename:join(rebar_utils:ebin_dir(), "dummy")).
|
|
|
|
eunit_dir() ->
|
|
filename:join(rebar_utils:get_cwd(), ?EUNIT_DIR).
|
|
|
|
setup_code_path() ->
|
|
%% Setup code path prior to compilation so that parse_transforms
|
|
%% and the like work properly. Also, be sure to add ebin_dir()
|
|
%% to the END of the code path so that we don't have to jump
|
|
%% through hoops to access the .app file
|
|
CodePath = code:get_path(),
|
|
true = code:add_patha(eunit_dir()),
|
|
true = code:add_pathz(rebar_utils:ebin_dir()),
|
|
CodePath.
|
|
|
|
%%
|
|
%% == get matching tests ==
|
|
%%
|
|
get_tests_and_modules(Config, ModuleBeamFiles, AllModules) ->
|
|
SelectedSuites = get_selected_suites(Config, AllModules),
|
|
{Tests, QualifiedTests} = get_qualified_and_unqualified_tests(Config),
|
|
Modules = get_test_modules(SelectedSuites, Tests,
|
|
QualifiedTests, ModuleBeamFiles),
|
|
FilteredModules = get_matching_modules(AllModules, Modules, QualifiedTests),
|
|
MatchedTests = get_matching_tests(Modules, Tests, QualifiedTests),
|
|
{MatchedTests, FilteredModules}.
|
|
|
|
%%
|
|
%% == get suites specified via 'suites' option ==
|
|
%%
|
|
get_selected_suites(Config, Modules) ->
|
|
RawSuites = get_suites(Config),
|
|
Suites = [list_to_atom(Suite) || Suite <- string:tokens(RawSuites, ",")],
|
|
[M || M <- Suites, lists:member(M, Modules)].
|
|
|
|
get_suites(Config) ->
|
|
case rebar_config:get_global(Config, suites, "") of
|
|
"" ->
|
|
rebar_config:get_global(Config, suite, "");
|
|
Suites ->
|
|
Suites
|
|
end.
|
|
|
|
get_qualified_and_unqualified_tests(Config) ->
|
|
RawFunctions = rebar_config:get_global(Config, tests, ""),
|
|
FunctionNames = [FunctionName ||
|
|
FunctionName <- string:tokens(RawFunctions, ",")],
|
|
get_qualified_and_unqualified_tests1(FunctionNames, [], []).
|
|
|
|
get_qualified_and_unqualified_tests1([], Functions, QualifiedFunctions) ->
|
|
{Functions, QualifiedFunctions};
|
|
get_qualified_and_unqualified_tests1([TestName|TestNames], Functions,
|
|
QualifiedFunctions) ->
|
|
case string:tokens(TestName, ":") of
|
|
[TestName] ->
|
|
Function = list_to_atom(TestName),
|
|
get_qualified_and_unqualified_tests1(
|
|
TestNames, [Function|Functions], QualifiedFunctions);
|
|
[ModuleName, FunctionName] ->
|
|
M = list_to_atom(ModuleName),
|
|
F = list_to_atom(FunctionName),
|
|
get_qualified_and_unqualified_tests1(TestNames, Functions,
|
|
[{M, F}|QualifiedFunctions]);
|
|
_ ->
|
|
?ABORT("Unsupported test function specification: ~s~n", [TestName])
|
|
end.
|
|
|
|
%% Provide modules which are to be searched for tests.
|
|
%% Several scenarios are possible:
|
|
%%
|
|
%% == randomize suites ==
|
|
%%
|
|
|
|
randomize_suites(Config, Modules) ->
|
|
case rebar_config:get_global(Config, random_suite_order, undefined) of
|
|
undefined ->
|
|
Modules;
|
|
"true" ->
|
|
Seed = crypto:rand_uniform(1, 65535),
|
|
randomize_suites1(Modules, Seed);
|
|
String ->
|
|
try list_to_integer(String) of
|
|
Seed ->
|
|
randomize_suites1(Modules, Seed)
|
|
catch
|
|
error:badarg ->
|
|
?ERROR("Bad random seed provided: ~p~n", [String]),
|
|
?FAIL
|
|
end
|
|
end.
|
|
|
|
randomize_suites1(Modules, Seed) ->
|
|
_ = random:seed(35, Seed, 1337),
|
|
?CONSOLE("Randomizing suite order with seed ~b~n", [Seed]),
|
|
[X||{_,X} <- lists:sort([{random:uniform(), M} || M <- Modules])].
|
|
|
|
%%
|
|
%% == get matching tests ==
|
|
%% 1) Specific tests have been provided and/or
|
|
%% no unqualified tests have been specified and
|
|
%% there were some qualified tests, then we can search for
|
|
%% functions in specified suites (or in empty set of suites).
|
|
%%
|
|
%% 2) Neither specific suites nor qualified test names have been
|
|
%% provided use ModuleBeamFiles which filters out "*_tests"
|
|
%% modules so EUnit won't doubly run them and cover only
|
|
%% calculates coverage on production code. However,
|
|
%% keep "*_tests" modules that are not automatically
|
|
%% included by EUnit.
|
|
%%
|
|
%% From 'Primitives' in the EUnit User's Guide
|
|
%% http://www.erlang.org/doc/apps/eunit/chapter.html
|
|
%% "In addition, EUnit will also look for another
|
|
%% module whose name is ModuleName plus the suffix
|
|
%% _tests, and if it exists, all the tests from that
|
|
%% module will also be added. (If ModuleName already
|
|
%% contains the suffix _tests, this is not done.) E.g.,
|
|
%% the specification {module, mymodule} will run all
|
|
%% tests in the modules mymodule and mymodule_tests.
|
|
%% Typically, the _tests module should only contain
|
|
%% test cases that use the public interface of the main
|
|
%% module (and no other code)."
|
|
get_test_modules(SelectedSuites, Tests, QualifiedTests, ModuleBeamFiles) ->
|
|
SuitesProvided = SelectedSuites =/= [],
|
|
OnlyQualifiedTestsProvided = QualifiedTests =/= [] andalso Tests =:= [],
|
|
if
|
|
SuitesProvided orelse OnlyQualifiedTestsProvided ->
|
|
SelectedSuites;
|
|
true ->
|
|
[rebar_utils:beam_to_mod(?EUNIT_DIR, N) ||
|
|
N <- ModuleBeamFiles]
|
|
end.
|
|
|
|
get_matching_modules(AllModules, Modules, QualifiedTests) ->
|
|
ModuleFilterMapper =
|
|
fun({M, _}) ->
|
|
case lists:member(M, AllModules) of
|
|
true -> {true, M};
|
|
_-> false
|
|
end
|
|
end,
|
|
ModulesFromQualifiedTests = lists:zf(ModuleFilterMapper, QualifiedTests),
|
|
lists:usort(Modules ++ ModulesFromQualifiedTests).
|
|
|
|
get_matching_tests(Modules, [], []) ->
|
|
Modules;
|
|
get_matching_tests(Modules, [], QualifiedTests) ->
|
|
FilteredQualifiedTests = filter_qualified_tests(Modules, QualifiedTests),
|
|
lists:merge(Modules, make_test_primitives(FilteredQualifiedTests));
|
|
get_matching_tests(Modules, Tests, QualifiedTests) ->
|
|
AllTests = lists:merge(QualifiedTests,
|
|
get_matching_tests1(Modules, Tests, [])),
|
|
make_test_primitives(AllTests).
|
|
|
|
filter_qualified_tests(Modules, QualifiedTests) ->
|
|
TestsFilter = fun({Module, _Function}) ->
|
|
lists:all(fun(M) -> M =/= Module end, Modules) end,
|
|
lists:filter(TestsFilter, QualifiedTests).
|
|
|
|
get_matching_tests1([], _Functions, TestFunctions) ->
|
|
TestFunctions;
|
|
|
|
get_matching_tests1([Module|TModules], Functions, TestFunctions) ->
|
|
%% Get module exports
|
|
ModuleStr = atom_to_list(Module),
|
|
ModuleExports = get_beam_test_exports(ModuleStr),
|
|
%% Get module _tests exports
|
|
TestModuleStr = string:concat(ModuleStr, "_tests"),
|
|
TestModuleExports = get_beam_test_exports(TestModuleStr),
|
|
%% Build tests {M, F} list
|
|
Tests = get_matching_tests2(Functions, {Module, ModuleExports},
|
|
{list_to_atom(TestModuleStr),
|
|
TestModuleExports}),
|
|
get_matching_tests1(TModules, Functions,
|
|
lists:merge([TestFunctions, Tests])).
|
|
|
|
get_matching_tests2(Functions, {Mod, ModExports}, {TestMod, TestModExports}) ->
|
|
%% Look for matching functions into ModExports
|
|
ModExportsStr = [atom_to_list(E1) || E1 <- ModExports],
|
|
TestModExportsStr = [atom_to_list(E2) || E2 <- TestModExports],
|
|
get_matching_exports(Functions, {Mod, ModExportsStr},
|
|
{TestMod, TestModExportsStr}, []).
|
|
|
|
get_matching_exports([], _, _, Matched) ->
|
|
Matched;
|
|
get_matching_exports([Function|TFunctions], {Mod, ModExportsStr},
|
|
{TestMod, TestModExportsStr}, Matched) ->
|
|
|
|
FunctionStr = atom_to_list(Function),
|
|
%% Get matching Function in module, otherwise look in _tests module
|
|
NewMatch = case get_matching_export(FunctionStr, ModExportsStr) of
|
|
[] ->
|
|
{TestMod, get_matching_export(FunctionStr,
|
|
TestModExportsStr)};
|
|
MatchingExport ->
|
|
{Mod, MatchingExport}
|
|
end,
|
|
case NewMatch of
|
|
{_, []} ->
|
|
get_matching_exports(TFunctions, {Mod, ModExportsStr},
|
|
{TestMod, TestModExportsStr}, Matched);
|
|
_ ->
|
|
get_matching_exports(TFunctions, {Mod, ModExportsStr},
|
|
{TestMod, TestModExportsStr},
|
|
[NewMatch|Matched])
|
|
end.
|
|
|
|
get_matching_export(_FunctionStr, []) ->
|
|
[];
|
|
get_matching_export(FunctionStr, [ExportStr|TExportsStr]) ->
|
|
case string:str(ExportStr, FunctionStr) of
|
|
1 ->
|
|
list_to_atom(ExportStr);
|
|
_ ->
|
|
get_matching_export(FunctionStr, TExportsStr)
|
|
end.
|
|
|
|
get_beam_test_exports(ModuleStr) ->
|
|
FilePath = filename:join(eunit_dir(),
|
|
string:concat(ModuleStr, ".beam")),
|
|
case filelib:is_regular(FilePath) of
|
|
true ->
|
|
{beam_file, _, Exports0, _, _, _} = beam_disasm:file(FilePath),
|
|
Exports1 = [FunName || {FunName, FunArity, _} <- Exports0,
|
|
FunArity =:= 0],
|
|
F = fun(FName) ->
|
|
FNameStr = atom_to_list(FName),
|
|
re:run(FNameStr, "_test(_)?") =/= nomatch
|
|
end,
|
|
lists:filter(F, Exports1);
|
|
_ ->
|
|
[]
|
|
end.
|
|
|
|
make_test_primitives(RawTests) ->
|
|
%% Use {test,M,F} and {generator,M,F} if at least R15B02. Otherwise,
|
|
%% use eunit_test:function_wrapper/2 fallback.
|
|
%% eunit_test:function_wrapper/2 was renamed to eunit_test:mf_wrapper/2
|
|
%% in R15B02; use that as >= R15B02 check.
|
|
%% TODO: remove fallback and use only {test,M,F} and {generator,M,F}
|
|
%% primitives once at least R15B02 is required.
|
|
{module, eunit_test} = code:ensure_loaded(eunit_test),
|
|
MakePrimitive = case erlang:function_exported(eunit_test, mf_wrapper, 2) of
|
|
true -> fun eunit_primitive/3;
|
|
false -> fun pre15b02_eunit_primitive/3
|
|
end,
|
|
|
|
?CONSOLE(" Running test function(s):~n", []),
|
|
F = fun({M, F2}, Acc) ->
|
|
?CONSOLE(" ~p:~p/0~n", [M, F2]),
|
|
FNameStr = atom_to_list(F2),
|
|
NewFunction =
|
|
case re:run(FNameStr, "_test_") of
|
|
nomatch ->
|
|
%% Normal test
|
|
MakePrimitive(test, M, F2);
|
|
_ ->
|
|
%% Generator
|
|
MakePrimitive(generator, M, F2)
|
|
end,
|
|
[NewFunction|Acc]
|
|
end,
|
|
lists:foldl(F, [], RawTests).
|
|
|
|
eunit_primitive(Type, M, F) ->
|
|
{Type, M, F}.
|
|
|
|
pre15b02_eunit_primitive(test, M, F) ->
|
|
eunit_test:function_wrapper(M, F);
|
|
pre15b02_eunit_primitive(generator, M, F) ->
|
|
{generator, eunit_test:function_wrapper(M, F)}.
|
|
|
|
%%
|
|
%% == run tests ==
|
|
%%
|
|
|
|
perform_eunit(Config, Tests) ->
|
|
EunitOpts = get_eunit_opts(Config),
|
|
|
|
%% Move down into ?EUNIT_DIR while we run tests so any generated files
|
|
%% are created there (versus in the source dir)
|
|
Cwd = rebar_utils:get_cwd(),
|
|
ok = file:set_cwd(?EUNIT_DIR),
|
|
|
|
EunitResult = (catch eunit:test(Tests, EunitOpts)),
|
|
|
|
%% Return to original working dir
|
|
ok = file:set_cwd(Cwd),
|
|
|
|
EunitResult.
|
|
|
|
get_eunit_opts(Config) ->
|
|
%% Enable verbose in eunit if so requested..
|
|
BaseOpts = case rebar_log:is_verbose(Config) of
|
|
true ->
|
|
[verbose];
|
|
false ->
|
|
[]
|
|
end,
|
|
|
|
BaseOpts ++ rebar_config:get_list(Config, eunit_opts, []).
|
|
|
|
%%
|
|
%% == reset_after_eunit ==
|
|
%%
|
|
|
|
status_before_eunit() ->
|
|
Apps = get_app_names(),
|
|
AppEnvs = [{App, application:get_all_env(App)} || App <- Apps],
|
|
{erlang:processes(), erlang:is_alive(), AppEnvs, ets:tab2list(ac_tab)}.
|
|
|
|
get_app_names() ->
|
|
[AppName || {AppName, _, _} <- application:loaded_applications()].
|
|
|
|
reset_after_eunit({OldProcesses, WasAlive, OldAppEnvs, _OldACs}) ->
|
|
IsAlive = erlang:is_alive(),
|
|
if not WasAlive andalso IsAlive ->
|
|
?DEBUG("Stopping net kernel....\n", []),
|
|
erl_epmd:stop(),
|
|
_ = net_kernel:stop(),
|
|
pause_until_net_kernel_stopped();
|
|
true ->
|
|
ok
|
|
end,
|
|
|
|
OldApps = [App || {App, _} <- OldAppEnvs],
|
|
Apps = get_app_names(),
|
|
_ = [begin
|
|
_ = case lists:member(App, OldApps) of
|
|
true -> ok;
|
|
false -> application:stop(App)
|
|
end,
|
|
ok = application:unset_env(App, K)
|
|
end || App <- Apps, App /= rebar,
|
|
{K, _V} <- application:get_all_env(App),
|
|
K =/= included_applications],
|
|
|
|
reconstruct_app_env_vars(Apps),
|
|
|
|
Processes = erlang:processes(),
|
|
_ = kill_extras(Processes -- OldProcesses),
|
|
|
|
ok.
|
|
|
|
kill_extras(Pids) ->
|
|
%% Killing any of the procs below will either:
|
|
%% 1. Interfere with stuff that we don't want interfered with, or
|
|
%% 2. May/will force the 'kernel' app to shutdown, which *will*
|
|
%% interfere with rebar's ability To Do Useful Stuff(tm).
|
|
%% This list may require changes as OTP versions and/or
|
|
%% rebar use cases change.
|
|
KeepProcs = [cover_server, eunit_server,
|
|
eqc, eqc_license, eqc_locked,
|
|
%% inet_gethost_native is started on demand, when
|
|
%% doing name lookups. It is under kernel_sup, under
|
|
%% a supervisor_bridge.
|
|
inet_gethost_native],
|
|
Killed = [begin
|
|
Info = case erlang:process_info(Pid) of
|
|
undefined -> [];
|
|
Else -> Else
|
|
end,
|
|
Keep1 = case proplists:get_value(registered_name, Info) of
|
|
undefined ->
|
|
false;
|
|
Name ->
|
|
lists:member(Name, KeepProcs)
|
|
end,
|
|
Keep2 = case proplists:get_value(dictionary, Info) of
|
|
undefined ->
|
|
false;
|
|
Ds ->
|
|
case proplists:get_value('$ancestors', Ds) of
|
|
undefined ->
|
|
false;
|
|
As ->
|
|
lists:member(kernel_sup, As)
|
|
end
|
|
end,
|
|
if Keep1 orelse Keep2 ->
|
|
ok;
|
|
true ->
|
|
?DEBUG("Kill ~p ~p\n", [Pid, Info]),
|
|
exit(Pid, kill),
|
|
Pid
|
|
end
|
|
end || Pid <- Pids],
|
|
case lists:usort(Killed) -- [ok] of
|
|
[] ->
|
|
?DEBUG("No processes to kill\n", []),
|
|
[];
|
|
Else ->
|
|
lists:foreach(fun(Pid) -> wait_until_dead(Pid) end, Else),
|
|
Else
|
|
end.
|
|
|
|
reconstruct_app_env_vars([App|Apps]) ->
|
|
CmdLine0 = proplists:get_value(App, init:get_arguments(), []),
|
|
CmdVars = [{list_to_atom(K), list_to_atom(V)} || {K, V} <- CmdLine0],
|
|
AppFile = (catch filename:join([code:lib_dir(App),
|
|
"ebin",
|
|
atom_to_list(App) ++ ".app"])),
|
|
AppVars = case file:consult(AppFile) of
|
|
{ok, [{application, App, Ps}]} ->
|
|
proplists:get_value(env, Ps, []);
|
|
_ ->
|
|
[]
|
|
end,
|
|
|
|
%% App vars specified in config files override those in the .app file.
|
|
%% Config files later in the args list override earlier ones.
|
|
AppVars1 = case init:get_argument(config) of
|
|
{ok, ConfigFiles} ->
|
|
{App, MergedAppVars} = lists:foldl(fun merge_app_vars/2,
|
|
{App, AppVars},
|
|
ConfigFiles),
|
|
MergedAppVars;
|
|
error ->
|
|
AppVars
|
|
end,
|
|
AllVars = CmdVars ++ AppVars1,
|
|
?DEBUG("Reconstruct ~p ~p\n", [App, AllVars]),
|
|
lists:foreach(fun({K, V}) -> application:set_env(App, K, V) end, AllVars),
|
|
reconstruct_app_env_vars(Apps);
|
|
reconstruct_app_env_vars([]) ->
|
|
ok.
|
|
|
|
merge_app_vars(ConfigFile, {App, AppVars}) ->
|
|
File = ensure_config_extension(ConfigFile),
|
|
FileAppVars = app_vars_from_config_file(File, App),
|
|
Dict1 = dict:from_list(AppVars),
|
|
Dict2 = dict:from_list(FileAppVars),
|
|
Dict3 = dict:merge(fun(_Key, _Value1, Value2) -> Value2 end, Dict1, Dict2),
|
|
{App, dict:to_list(Dict3)}.
|
|
|
|
ensure_config_extension(File) ->
|
|
%% config files must end with .config on disk but when specifying them
|
|
%% via the -config option the extension is optional
|
|
BaseFileName = filename:basename(File, ".config"),
|
|
DirName = filename:dirname(File),
|
|
filename:join(DirName, BaseFileName ++ ".config").
|
|
|
|
app_vars_from_config_file(File, App) ->
|
|
case file:consult(File) of
|
|
{ok, [Env]} ->
|
|
proplists:get_value(App, Env, []);
|
|
_ ->
|
|
[]
|
|
end.
|
|
|
|
wait_until_dead(Pid) when is_pid(Pid) ->
|
|
Ref = erlang:monitor(process, Pid),
|
|
receive
|
|
{'DOWN', Ref, process, _Obj, Info} ->
|
|
Info
|
|
after 10*1000 ->
|
|
exit({timeout_waiting_for, Pid})
|
|
end;
|
|
wait_until_dead(_) ->
|
|
ok.
|
|
|
|
pause_until_net_kernel_stopped() ->
|
|
pause_until_net_kernel_stopped(10).
|
|
|
|
pause_until_net_kernel_stopped(0) ->
|
|
exit(net_kernel_stop_failed);
|
|
pause_until_net_kernel_stopped(N) ->
|
|
case node() of
|
|
'nonode@nohost' ->
|
|
?DEBUG("Stopped net kernel.\n", []),
|
|
ok;
|
|
_ ->
|
|
timer:sleep(100),
|
|
pause_until_net_kernel_stopped(N - 1)
|
|
end.
|