diff options
Diffstat (limited to 'lib/common_test/src')
28 files changed, 16051 insertions, 0 deletions
diff --git a/lib/common_test/src/Makefile b/lib/common_test/src/Makefile new file mode 100644 index 0000000000..e7e2d1275d --- /dev/null +++ b/lib/common_test/src/Makefile @@ -0,0 +1,141 @@ +# +# %CopyrightBegin% +# +# Copyright Ericsson AB 2003-2009. All Rights Reserved. +# +# The contents of this file are subject to the Erlang Public License, +# Version 1.1, (the "License"); you may not use this file except in +# compliance with the License. You should have received a copy of the +# Erlang Public License along with this software. If not, it can be +# retrieved online at http://www.erlang.org/. +# +# Software distributed under the License is distributed on an "AS IS" +# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +# the License for the specific language governing rights and limitations +# under the License. +# +# %CopyrightEnd% +# + +include $(ERL_TOP)/make/target.mk + +# ---------------------------------------------------- +# Configuration info. +# ---------------------------------------------------- +include $(ERL_TOP)/make/$(TARGET)/otp.mk + +# ---------------------------------------------------- +# Application version +# ---------------------------------------------------- +include ../vsn.mk +VSN=$(COMMON_TEST_VSN) + +# ---------------------------------------------------- +# Release directory specification +# ---------------------------------------------------- +RELSYSDIR = $(RELEASE_PATH)/lib/common_test-$(VSN) + +# ---------------------------------------------------- +# Target Specs +# ---------------------------------------------------- + +MODULES= \ + ct_line \ + ct \ + ct_logs \ + ct_framework \ + ct_ftp \ + ct_ssh \ + ct_snmp \ + ct_gen_conn \ + ct_rpc \ + ct_run \ + ct_master \ + ct_telnet \ + ct_util \ + ct_cover \ + ct_testspec \ + ct_event \ + ct_master_event \ + ct_master_logs \ + ct_master_status \ + ct_repeat \ + ct_telnet_client \ + ct_make \ + vts \ + unix_telnet + +TARGET_MODULES= $(MODULES:%=$(EBIN)/%) + +ERL_FILES= $(MODULES:=.erl) +HRL_FILES = \ + ct_util.hrl +EXTERNAL_HRL_FILES = \ + ../include/ct.hrl \ + ../include/ct_event.hrl + +EXTERNAL_INC_PATH = ../include + +DTD_FILES = \ + mp.dtd + +# ---------------------------------------------------- +# FLAGS +# ---------------------------------------------------- +ERL_COMPILE_FLAGS += -pa ../ebin -I../include -I $(ERL_TOP)/lib/snmp/include/ \ + -I../../test_server/include -I../../xmerl/inc/ \ + -I $(ERL_TOP)/lib/kernel/include + +# ---------------------------------------------------- +# Targets +# ---------------------------------------------------- +TARGET_FILES = \ + $(GEN_ERL_FILES:%.erl=$(EBIN)/%.$(EMULATOR)) \ + $(MODULES:%=$(EBIN)/%.$(EMULATOR)) \ + $(APP_TARGET) $(APPUP_TARGET) + +APP_FILE= common_test.app +APP_SRC= $(APP_FILE).src +APP_TARGET= $(EBIN)/$(APP_FILE) + +APPUP_FILE= common_test.appup +APPUP_SRC= $(APPUP_FILE).src +APPUP_TARGET= $(EBIN)/$(APPUP_FILE) + +tests debug opt: $(TARGET_FILES) + +docs: + +clean: + rm -f $(TARGET_FILES) $(GEN_FILES) + rm -f core + +# ---------------------------------------------------- +# Special Build Targets +# ---------------------------------------------------- +$(APP_TARGET): $(APP_SRC) ../vsn.mk + sed -e 's;%VSN%;$(VSN);' $< > $@ + +$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk + sed -e 's;%VSN%;$(VSN);' $< > $@ + +# ---------------------------------------------------- +# Release Target +# ---------------------------------------------------- +include $(ERL_TOP)/make/otp_release_targets.mk + +release_spec: opt + $(INSTALL_DIR) $(RELSYSDIR)/src + $(INSTALL_DATA) $(ERL_FILES) $(HRL_FILES) $(RELSYSDIR)/src + $(INSTALL_DIR) $(RELSYSDIR)/ebin + $(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin + $(INSTALL_DIR) $(RELSYSDIR)/include + $(INSTALL_DATA) $(EXTERNAL_HRL_FILES) $(RELSYSDIR)/include + +release_tests_spec: opt + $(INSTALL_DIR) $(RELEASE_PATH)/common_test_test + $(INSTALL_DATA) $(ERL_FILES) \ + $(HRL_FILES) $(TARGET_FILES) $(RELEASE_PATH)/common_test_test + +release_docs_spec: docs + diff --git a/lib/common_test/src/common_test.app.src b/lib/common_test/src/common_test.app.src new file mode 100644 index 0000000000..7b72932ad4 --- /dev/null +++ b/lib/common_test/src/common_test.app.src @@ -0,0 +1,55 @@ +% This is an -*- erlang -*- file. +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% + +{application, common_test, + [{description, "The OTP Common Test application"}, + {vsn, "%VSN%"}, + {modules, [ct_cover, + ct, + ct_event, + ct_framework, + ct_ftp, + ct_gen_conn, + ct_line, + ct_logs, + ct_make, + ct_master, + ct_master_event, + ct_master_logs, + ct_master_status, + ct_repeat, + ct_rpc, + ct_run, + ct_snmp, + ct_ssh, + ct_telnet_client, + ct_telnet, + ct_testspec, + ct_util, + unix_telnet, + vts + ]}, + {registered, [ct_logs, + ct_util_server, + ct_make_ref, + vts, + ct_master, + ct_master_logs]}, + {applications, [kernel,stdlib]}, + {env, []}]}. + diff --git a/lib/common_test/src/common_test.appup.src b/lib/common_test/src/common_test.appup.src new file mode 100644 index 0000000000..0fbe5f23f7 --- /dev/null +++ b/lib/common_test/src/common_test.appup.src @@ -0,0 +1 @@ +{"%VSN%",[],[]}.
\ No newline at end of file diff --git a/lib/common_test/src/ct.erl b/lib/common_test/src/ct.erl new file mode 100644 index 0000000000..8ae041e5b4 --- /dev/null +++ b/lib/common_test/src/ct.erl @@ -0,0 +1,789 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Main user interface for the Common Test framework. +%%% +%%% <p> This module implements the command line interface for running +%%% tests and some basic functions for common test case issues +%%% such as configuration and logging. </p> +%%% +%%% <p><strong>Test Suite Support Macros</strong></p> +%%% +%%% <p>The <code>config</code> macro is defined in <code>ct.hrl</code>. This +%%% macro should be used to retrieve information from the +%%% <code>Config</code> variable sent to all test cases. It is used with two +%%% arguments, where the first is the name of the configuration +%%% variable you wish to retrieve, and the second is the <code>Config</code> +%%% variable supplied to the test case.</p> +%%% +%%% <p>Possible configuration variables include:</p> +%%% <ul> +%%% <li><code>data_dir</code> - Data file directory.</li> +%%% <li><code>priv_dir</code> - Scratch file directory.</li> +%%% <li>Whatever added by <code>init_per_suite/1</code> or +%%% <code>init_per_testcase/2</code> in the test suite.</li> +%%% </ul> + +%%% @type var_name() = atom(). A variable name which is specified when +%%% <code>ct:require/2</code> is called, +%%% e.g. <code>ct:require(mynodename,{node,[telnet]})</code> +%%% +%%% @type target_name() = var_name(). The name of a target. +%%% +%%% @type handle() = ct_gen_conn:handle() | term(). The identity of a +%%% specific connection. + +-module(ct). + +%% Command line user interface for running tests +-export([install/1, run/1, run/2, run/3, + run_test/1, run_testspec/1, step/3, step/4, + start_interactive/0, stop_interactive/0]). + +%% Test suite API +-export([require/1, require/2, + get_config/1, get_config/2, get_config/3, + log/1, log/2, log/3, + print/1, print/2, print/3, + pal/1, pal/2, pal/3, + fail/1, comment/1, + testcases/2, userdata/2, userdata/3]). + +%% Other interface functions +-export([get_status/0, abort_current_testcase/1, + encrypt_config_file/2, encrypt_config_file/3, + decrypt_config_file/2, decrypt_config_file/3]). + + +-export([get_target_name/1]). +-export([parse_table/1, listenv/1]). + +%%%----------------------------------------------------------------- +%%% @spec install(Opts) -> ok | {error,Reason} +%%% Opts = [Opt] +%%% Opt = {config,ConfigFiles} | {event_handler,Modules} | +%%% {decrypt,KeyOrFile} +%%% ConfigFiles = [ConfigFile] +%%% ConfigFile = string() +%%% Modules = [atom()] +%%% KeyOrFile = {key,Key} | {file,KeyFile} +%%% Key = string() +%%% KeyFile = string() +%%% @doc Install config files and event handlers. +%%% +%%% <p>Run this function once before first test.</p> +%%% +%%% <p>Example:<br/> +%%% <code>install([{config,["config_node.ctc","config_user.ctc"]}])</code>.</p> +%%% +%%% <p>Note that this function is automatically run by the +%%% <code>run_test</code> script.</p> +install(Opts) -> + ct_run:install(Opts). + +%%%----------------------------------------------------------------- +%%% @spec run(TestDir,Suite,Cases) -> Result +%%% TestDir = string() +%%% Suite = atom() +%%% Cases = atom() | [atom()] +%%% Result = [TestResult] | {error,Reason} +%%% +%%% @doc Run the given testcase(s). +%%% +%%% <p>Requires that <code>ct:install/1</code> has been run first.</p> +%%% +%%% <p>Suites (*_SUITE.erl) files must be stored in +%%% <code>TestDir</code> or <code>TestDir/test</code>. All suites +%%% will be compiled when test is run.</p> +run(TestDir,Suite,Cases) -> + ct_run:run(TestDir,Suite,Cases). + +%%%----------------------------------------------------------------- +%%% @spec run(TestDir,Suite) -> Result +%%% +%%% @doc Run all testcases in the given suite. +%%% @see run/3. +run(TestDir,Suite) -> + ct_run:run(TestDir,Suite). + +%%%----------------------------------------------------------------- +%%% @spec run(TestDirs) -> Result +%%% TestDirs = TestDir | [TestDir] +%%% +%%% @doc Run all testcases in all suites in the given directories. +%%% @see run/3. +run(TestDirs) -> + ct_run:run(TestDirs). + +%%%----------------------------------------------------------------- +%%% @spec run_test(Opts) -> Result +%%% Opts = [OptTuples] +%%% OptTuples = {config,CfgFiles} | {dir,TestDirs} | {suite,Suites} | +%%% {testcase,Cases} | {group,Groups} | {spec,TestSpecs} | +%%% {allow_user_terms,Bool} | {logdir,LogDir} | +%%% {silent_connections,Conns} | {cover,CoverSpecFile} | +%%% {step,StepOpts} | {event_handler,EventHandlers} | {include,InclDirs} | +%%% {auto_compile,Bool} | {repeat,N} | {duration,DurTime} | +%%% {until,StopTime} | {force_stop,Bool} | {decrypt,DecryptKeyOrFile} | +%%% {refresh_logs,LogDir} | {basic_html,Bool} +%%% CfgFiles = [string()] | string() +%%% TestDirs = [string()] | string() +%%% Suites = [string()] | string() +%%% Cases = [atom()] | atom() +%%% Groups = [atom()] | atom() +%%% TestSpecs = [string()] | string() +%%% LogDir = string() +%%% Conns = all | [atom()] +%%% CoverSpecFile = string() +%%% StepOpts = [StepOpt] | [] +%%% StepOpt = config | keep_inactive +%%% EventHandlers = EH | [EH] +%%% EH = atom() | {atom(),InitArgs} | {[atom()],InitArgs} +%%% InitArgs = [term()] +%%% InclDirs = [string()] | string() +%%% N = integer() +%%% DurTime = string(HHMMSS) +%%% StopTime = string(YYMoMoDDHHMMSS) | string(HHMMSS) +%%% DecryptKeyOrFile = {key,DecryptKey} | {file,DecryptFile} +%%% DecryptKey = string() +%%% DecryptFile = string() +%%% Result = [TestResult] | {error,Reason} +%%% @doc Run tests as specified by the combination of options in <code>Opts</code>. +%%% The options are the same as those used with the <code>run_test</code> script. +%%% Note that here a <code>TestDir</code> can be used to point out the path to +%%% a <code>Suite</code>. Note also that the option <code>testcase</code> +%%% corresponds to the <code>-case</code> option in the <code>run_test</code> +%%% script. Configuration files specified in <code>Opts</code> will be +%%% installed automatically at startup. +run_test(Opts) -> + ct_run:run_test(Opts). + +%%%----------------------------------------------------------------- +%%% @spec run_testspec(TestSpec) -> Result +%%% TestSpec = [term()] +%%% @doc Run test specified by <code>TestSpec</code>. The terms are +%%% the same as those used in test specification files. +run_testspec(TestSpec) -> + ct_run:run_testspec(TestSpec). + +%%%----------------------------------------------------------------- +%%% @spec step(TestDir,Suite,Case) -> Result +%%% Case = atom() +%%% +%%% @doc Step through a test case with the debugger. +%%% @see run/3 +step(TestDir,Suite,Case) -> + ct_run:step(TestDir,Suite,Case). + +%%%----------------------------------------------------------------- +%%% @spec step(TestDir,Suite,Case,Opts) -> Result +%%% Case = atom() +%%% Opts = [Opt] | [] +%%% Opt = config | keep_inactive +%%% +%%% @doc Step through a test case with the debugger. If the +%%% <code>config</code> option has been given, breakpoints will +%%% be set also on the configuration functions in <code>Suite</code>. +%%% @see run/3 +step(TestDir,Suite,Case,Opts) -> + ct_run:step(TestDir,Suite,Case,Opts). + +%%%----------------------------------------------------------------- +%%% @spec start_interactive() -> ok +%%% +%%% @doc Start CT in interactive mode. +%%% +%%% <p>From this mode all test case support functions can be executed +%%% directly from the erlang shell. The interactive mode can also be +%%% started from the unix command line with <code>run_test -shell +%%% [-config File...]</code>.</p> +%%% +%%% <p>If any functions using "required config data" (e.g. telnet or +%%% ftp functions) are to be called from the erlang shell, config data +%%% must first be required with <code>ct:require/2</code>.</p> +%%% +%%% <p>Example:<br/> +%%% <code>> ct:require(unix_telnet, unix).</code><br/> +%%% <code>ok</code><br/> +%%% <code>> ct_telnet:open(unix_telnet).</code><br/> +%%% <code>{ok,<0.105.0>}</code><br/> +%%% <code>> ct_telnet:cmd(unix_telnet, "ls .").</code><br/> +%%% <code>{ok,["ls","file1 ...",...]}</code></p> +start_interactive() -> + ct_util:start(interactive). + +%%%----------------------------------------------------------------- +%%% @spec stop_interactive() -> ok +%%% +%%% @doc Exit the interactive mode. +%%% @see start_interactive/0 +stop_interactive() -> + ct_util:stop(normal). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%% MISC INTERFACE +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +%%%----------------------------------------------------------------- +%%% @spec require(Required) -> ok | {error,Reason} +%%% Required = Key | {Key,SubKeys} +%%% Key = atom() +%%% SubKeys = SubKey | [SubKey] +%%% SubKey = atom() +%%% +%%% @doc Check if the required configuration is available. +%%% +%%% <p>Example: require the variable <code>myvar</code>:<br/> +%%% <code>ok = ct:require(myvar)</code></p> +%%% +%%% <p>In this case the config file must at least contain:</p> +%%% <pre> +%%% {myvar,Value}.</pre> +%%% +%%% <p>Example: require the variable <code>myvar</code> with +%%% subvariable <code>sub1</code>:<br/> +%%% <code>ok = ct:require({myvar,sub1})</code></p> +%%% +%%% <p>In this case the config file must at least contain:</p> +%%% <pre> +%%% {myvar,[{sub1,Value}]}.</pre> +%%% +%%% @see require/2 +%%% @see get_config/1 +%%% @see get_config/2 +%%% @see get_config/3 +require(Required) -> + ct_util:require(Required). + +%%%----------------------------------------------------------------- +%%% @spec require(Name,Required) -> ok | {error,Reason} +%%% Name = atom() +%%% Required = Key | {Key,SubKeys} +%%% Key = atom() +%%% SubKeys = SubKey | [SubKey] +%%% SubKey = atom() +%%% +%%% @doc Check if the required configuration is available, and give it +%%% a name. +%%% +%%% <p>If the requested data is available, the main entry will be +%%% associated with <code>Name</code> so that the value of the element +%%% can be read with <code>get_config/1,2</code> provided +%%% <code>Name</code> instead of the <code>Key</code>.</p> +%%% +%%% <p>Example: Require one node with a telnet connection and an +%%% ftp connection. Name the node <code>a</code>:<br/> <code>ok = +%%% ct:require(a,{node,[telnet,ftp]}).</code><br/> All references +%%% to this node may then use the node name. E.g. you can fetch a +%%% file over ftp like this:<br/> +%%% <code>ok = ct:ftp_get(a,RemoteFile,LocalFile).</code></p> +%%% +%%% <p>For this to work, the config file must at least contain:</p> +%%% <pre> +%%% {node,[{telnet,IpAddr}, +%%% {ftp,IpAddr}]}.</pre> +%%% +%%% @see require/1 +%%% @see get_config/1 +%%% @see get_config/2 +%%% @see get_config/3 +require(Name,Required) -> + ct_util:require(Name,Required). + +%%%----------------------------------------------------------------- +%%% @spec get_config(Required) -> Value +%%% @equiv get_config(Required,undefined,[]) +get_config(Required) -> + ct_util:get_config(Required,undefined,[]). + +%%%----------------------------------------------------------------- +%%% @spec get_config(Required,Default) -> Value +%%% @equiv get_config(Required,Default,[]) +get_config(Required,Default) -> + ct_util:get_config(Required,Default,[]). + +%%%----------------------------------------------------------------- +%%% @spec get_config(Required,Default,Opts) -> ValueOrElement +%%% Required = KeyOrName | {KeyOrName,SubKey} +%%% KeyOrName = atom() +%%% SubKey = atom() +%%% Default = term() +%%% Opts = [Opt] | [] +%%% Opt = element | all +%%% ValueOrElement = term() | Default +%%% +%%% @doc Read config data values. +%%% +%%% <p>This function returns the matching value(s) or config element(s), +%%% given a config variable key or its associated name +%%% (if one has been specified with <code>require/2</code> or a +%%% require statement).</p> +%%% +%%% <p>Example, given the following config file:</p> +%%% <pre> +%%% {unix,[{telnet,IpAddr}, +%%% {username,Username}, +%%% {password,Password}]}.</pre> +%%% <p><code>get_config(unix,Default) -> +%%% [{telnet,IpAddr}, +%%% {username,Username}, +%%% {password,Password}]</code><br/> +%%% <code>get_config({unix,telnet},Default) -> IpAddr</code><br/> +%%% <code>get_config({unix,ftp},Default) -> Default</code><br/> +%%% <code>get_config(unknownkey,Default) -> Default</code></p> +%%% +%%% <p>If a config variable key has been associated with a name (by +%%% means of <code>require/2</code> or a require statement), the name +%%% may be used instead of the key to read the value:</p> +%%% +%%% <p><code>require(myhost,unix) -> ok</code><br/> +%%% <code>get_config(myhost,Default) -> +%%% [{telnet,IpAddr}, +%%% {username,Username}, +%%% {password,Password}]</code></p> +%%% +%%% <p>If a config variable is defined in multiple files and you want to +%%% access all possible values, use the <code>all</code> option. The +%%% values will be returned in a list and the order of the elements +%%% corresponds to the order that the config files were specified at +%%% startup.</p> +%%% +%%% <p>If you want config elements (key-value tuples) returned as result +%%% instead of values, use the <code>element</code> option. +%%% The returned elements will then be on the form <code>{KeyOrName,Value}</code>, +%%% or (in case a subkey has been specified) +%%% <code>{{KeyOrName,SubKey},Value}</code></p> +%%% +%%% @see get_config/1 +%%% @see get_config/2 +%%% @see require/1 +%%% @see require/2 +get_config(Required,Default,Opts) -> + ct_util:get_config(Required,Default,Opts). + +%%%----------------------------------------------------------------- +%%% @spec log(Format) -> ok +%%% @equiv log(default,Format,[]) +log(Format) -> + log(default,Format,[]). + +%%%----------------------------------------------------------------- +%%% @spec log(X1,X2) -> ok +%%% X1 = Category | Format +%%% X2 = Format | Args +%%% @equiv log(Category,Format,Args) +log(X1,X2) -> + {Category,Format,Args} = + if is_atom(X1) -> {X1,X2,[]}; + is_list(X1) -> {default,X1,X2} + end, + log(Category,Format,Args). + +%%%----------------------------------------------------------------- +%%% @spec log(Category,Format,Args) -> ok +%%% Category = atom() +%%% Format = string() +%%% Args = list() +%%% +%%% @doc Printout from a testcase to the log. +%%% +%%% <p>This function is meant for printing stuff directly from a +%%% testcase (i.e. not from within the CT framework) in the test +%%% log.</p> +%%% +%%% <p>Default <code>Category</code> is <code>default</code> and +%%% default <code>Args</code> is <code>[]</code>.</p> +log(Category,Format,Args) -> + ct_logs:tc_log(Category,Format,Args). + + +%%%----------------------------------------------------------------- +%%% @spec print(Format) -> ok +%%% @equiv print(default,Format,[]) +print(Format) -> + print(default,Format,[]). + +%%%----------------------------------------------------------------- +%%% @equiv print(Category,Format,Args) +print(X1,X2) -> + {Category,Format,Args} = + if is_atom(X1) -> {X1,X2,[]}; + is_list(X1) -> {default,X1,X2} + end, + print(Category,Format,Args). + +%%%----------------------------------------------------------------- +%%% @spec print(Category,Format,Args) -> ok +%%% Category = atom() +%%% Format = string() +%%% Args = list() +%%% +%%% @doc Printout from a testcase to the console. +%%% +%%% <p>This function is meant for printing stuff from a testcase on +%%% the console.</p> +%%% +%%% <p>Default <code>Category</code> is <code>default</code> and +%%% default <code>Args</code> is <code>[]</code>.</p> +print(Category,Format,Args) -> + ct_logs:tc_print(Category,Format,Args). + + +%%%----------------------------------------------------------------- +%%% @spec pal(Format) -> ok +%%% @equiv pal(default,Format,[]) +pal(Format) -> + pal(default,Format,[]). + +%%%----------------------------------------------------------------- +%%% @spec pal(X1,X2) -> ok +%%% X1 = Category | Format +%%% X2 = Format | Args +%%% @equiv pal(Category,Format,Args) +pal(X1,X2) -> + {Category,Format,Args} = + if is_atom(X1) -> {X1,X2,[]}; + is_list(X1) -> {default,X1,X2} + end, + pal(Category,Format,Args). + +%%%----------------------------------------------------------------- +%%% @spec pal(Category,Format,Args) -> ok +%%% Category = atom() +%%% Format = string() +%%% Args = list() +%%% +%%% @doc Print and log from a testcase. +%%% +%%% <p>This function is meant for printing stuff from a testcase both +%%% in the log and on the console.</p> +%%% +%%% <p>Default <code>Category</code> is <code>default</code> and +%%% default <code>Args</code> is <code>[]</code>.</p> +pal(Category,Format,Args) -> + ct_logs:tc_pal(Category,Format,Args). + + +%%%----------------------------------------------------------------- +%%% @spec fail(Reason) -> void() +%%% Reason = term() +%%% +%%% @doc Terminate a test case with the given error +%%% <code>Reason</code>. +fail(Reason) -> + exit({test_case_failed,Reason}). + +%%%----------------------------------------------------------------- +%%% @spec comment(Comment) -> void() +%%% Comment = term() +%%% +%%% @doc Print the given <code>Comment</code> in the comment field of +%%% the table on the test suite result page. +%%% +%%% <p>If called several times, only the last comment is printed. +%%% <code>comment/1</code> is also overwritten by the return value +%%% <code>{comment,Comment}</code> or by the function +%%% <code>fail/1</code> (which prints <code>Reason</code> as a +%%% comment).</p> +comment(Comment) when is_list(Comment) -> + Formatted = + case (catch io_lib:format("~s",[Comment])) of + {'EXIT',_} -> % it's a list not a string + io_lib:format("~p",[Comment]); + String -> + String + end, + send_html_comment(lists:flatten(Formatted)); +comment(Comment) -> + Formatted = io_lib:format("~p",[Comment]), + send_html_comment(lists:flatten(Formatted)). + +send_html_comment(Comment) -> + Html = "<font color=\"green\">" ++ Comment ++ "</font>", + ct_util:set_testdata({comment,Html}), + test_server:comment(Html). + + +%%%----------------------------------------------------------------- +%%% @spec get_target_name(Handle) -> {ok,TargetName} | {error,Reason} +%%% Handle = handle() +%%% TargetName = target_name() +%%% @doc Return the name of the target that the given connection +%%% belongs to. +get_target_name(Handle) -> + ct_util:get_target_name(Handle). + +%%%----------------------------------------------------------------- +%%% @spec parse_table(Data) -> {Heading,Table} +%%% Data = [string()] +%%% Heading = tuple() +%%% Table = [tuple()] +%%% +%%% @doc Parse the printout from an SQL table and return a list of tuples. +%%% +%%% <p>The printout to parse would typically be the result of a +%%% <code>select</code> command in SQL. The returned +%%% <code>Table</code> is a list of tuples, where each tuple is a row +%%% in the table.</p> +%%% +%%% <p><code>Heading</code> is a tuple of strings representing the +%%% headings of each column in the table.</p> +parse_table(Data) -> + ct_util:parse_table(Data). + +%%%----------------------------------------------------------------- +%%% @spec listenv(Telnet) -> [Env] +%%% Telnet = term() +%%% Env = {Key,Value} +%%% Key = string() +%%% Value = string() +%%% +%%% @doc Performs the listenv command on the given telnet connection +%%% and returns the result as a list of Key-Value pairs. +listenv(Telnet) -> + ct_util:listenv(Telnet). + + +%%%----------------------------------------------------------------- +%%% @spec testcases(TestDir, Suite) -> Testcases | {error,Reason} +%%% TestDir = string() +%%% Suite = atom() +%%% Testcases = list() +%%% Reason = term() +%%% +%%% @doc Returns all testcases in the specified suite. +testcases(TestDir, Suite) -> + case make_and_load(TestDir, Suite) of + E = {error,_} -> + E; + _ -> + case (catch Suite:all()) of + {'EXIT',Reason} -> + {error,Reason}; + TCs -> + TCs + end + end. + +make_and_load(Dir, Suite) -> + EnvInclude = + case os:getenv("CT_INCLUDE_PATH") of + false -> []; + CtInclPath -> string:tokens(CtInclPath, [$:,$ ,$,]) + end, + StartInclude = + case init:get_argument(include) of + {ok,[Dirs]} -> Dirs; + _ -> [] + end, + UserInclude = EnvInclude ++ StartInclude, + case ct_run:run_make(Dir, Suite, UserInclude) of + MErr = {error,_} -> + MErr; + _ -> + TestDir = ct_util:get_testdir(Dir, Suite), + File = filename:join(TestDir, atom_to_list(Suite)), + case code:soft_purge(Suite) of + true -> + code:load_abs(File); + false -> % will use loaded + {module,Suite} + end + end. + +%%%----------------------------------------------------------------- +%%% @spec userdata(TestDir, Suite) -> SuiteUserData | {error,Reason} +%%% TestDir = string() +%%% Suite = atom() +%%% SuiteUserData = [term()] +%%% Reason = term() +%%% +%%% @doc Returns any data specified with the tag <code>userdata</code> +%%% in the list of tuples returned from <code>Suite:suite/0</code>. +userdata(TestDir, Suite) -> + case make_and_load(TestDir, Suite) of + E = {error,_} -> + E; + _ -> + Info = (catch Suite:suite()), + get_userdata(Info, "suite/0") + end. + +get_userdata({'EXIT',{undef,_}}, Spec) -> + {error,list_to_atom(Spec ++ " is not defined")}; +get_userdata({'EXIT',Reason}, Spec) -> + {error,{list_to_atom("error in " ++ Spec),Reason}}; +get_userdata(List, _) when is_list(List) -> + Fun = fun({userdata,Data}, Acc) -> [Data | Acc]; + (_, Acc) -> Acc + end, + case lists:foldl(Fun, [], List) of + Terms -> + lists:flatten(lists:reverse(Terms)) + end; +get_userdata(_BadTerm, Spec) -> + {error,list_to_atom(Spec ++ " must return a list")}. + +%%%----------------------------------------------------------------- +%%% @spec userdata(TestDir, Suite, Case) -> TCUserData | {error,Reason} +%%% TestDir = string() +%%% Suite = atom() +%%% Case = atom() +%%% TCUserData = [term()] +%%% Reason = term() +%%% +%%% @doc Returns any data specified with the tag <code>userdata</code> +%%% in the list of tuples returned from <code>Suite:Case/0</code>. +userdata(TestDir, Suite, Case) -> + case make_and_load(TestDir, Suite) of + E = {error,_} -> + E; + _ -> + Info = (catch apply(Suite, Case, [])), + get_userdata(Info, atom_to_list(Case)++"/0") + end. + + +%%%----------------------------------------------------------------- +%%% @spec get_status() -> TestStatus | {error,Reason} +%%% TestStatus = [StatusElem] +%%% StatusElem = {current,{Suite,TestCase}} | {successful,Successful} | +%%% {failed,Failed} | {skipped,Skipped} | {total,Total} +%%% Suite = atom() +%%% TestCase = atom() +%%% Successful = integer() +%%% Failed = integer() +%%% Skipped = {UserSkipped,AutoSkipped} +%%% UserSkipped = integer() +%%% AutoSkipped = integer() +%%% Total = integer() +%%% Reason = term() +%%% +%%% @doc Returns status of ongoing test. The returned list contains info about +%%% which test case is currently executing, as well as counters for +%%% successful, failed, skipped, and total test cases so far. +get_status() -> + case get_testdata(curr_tc) of + {ok,TestCase} -> + case get_testdata(stats) of + {ok,{Ok,Failed,Skipped={UserSkipped,AutoSkipped}}} -> + [{current,TestCase}, + {successful,Ok}, + {failed,Failed}, + {skipped,Skipped}, + {total,Ok+Failed+UserSkipped+AutoSkipped}]; + Err1 -> Err1 + end; + Err2 -> Err2 + end. + +get_testdata(Key) -> + case catch ct_util:get_testdata(Key) of + Error = {error,_Reason} -> + Error; + {'EXIT',_Reason} -> + no_tests_running; + Data -> + {ok,Data} + end. + +%%%----------------------------------------------------------------- +%%% @spec abort_current_testcase(Reason) -> ok | {error,no_testcase_running} +%%% Reason = term() +%%% +%%% @doc <p>When calling this function, the currently executing test case will be aborted. +%%% It is the user's responsibility to know for sure which test case is currently +%%% executing. The function is therefore only safe to call from a function which +%%% has been called (or synchronously invoked) by the test case.</p> +%%% +%%% <p><code>Reason</code>, the reason for aborting the test case, is printed +%%% in the test case log.</p> +abort_current_testcase(Reason) -> + test_server_ctrl:abort_current_testcase(Reason). + +%%%----------------------------------------------------------------- +%%% @spec encrypt_config_file(SrcFileName, EncryptFileName) -> +%%% ok | {error,Reason} +%%% SrcFileName = string() +%%% EncryptFileName = string() +%%% Reason = term() +%%% +%%% @doc <p>This function encrypts the source config file with DES3 and +%%% saves the result in file <code>EncryptFileName</code>. The key, +%%% a string, must be available in a text file named +%%% <code>.ct_config.crypt</code> in the current directory, or the +%%% home directory of the user (it is searched for in that order).</p> +%%% <p>See the Common Test User's Guide for information about using +%%% encrypted config files when running tests.</p> +%%% <p>See the <code>crypto</code> application for details on DES3 +%%% encryption/decryption.</p> +encrypt_config_file(SrcFileName, EncryptFileName) -> + ct_util:encrypt_config_file(SrcFileName, EncryptFileName). + +%%%----------------------------------------------------------------- +%%% @spec encrypt_config_file(SrcFileName, EncryptFileName, KeyOrFile) -> +%%% ok | {error,Reason} +%%% SrcFileName = string() +%%% EncryptFileName = string() +%%% KeyOrFile = {key,string()} | {file,string()} +%%% Reason = term() +%%% +%%% @doc <p>This function encrypts the source config file with DES3 and +%%% saves the result in the target file <code>EncryptFileName</code>. +%%% The encryption key to use is either the value in +%%% <code>{key,Key}</code> or the value stored in the file specified +%%% by <code>{file,File}</code>.</p> +%%% <p>See the Common Test User's Guide for information about using +%%% encrypted config files when running tests.</p> +%%% <p>See the <code>crypto</code> application for details on DES3 +%%% encryption/decryption.</p> +encrypt_config_file(SrcFileName, EncryptFileName, KeyOrFile) -> + ct_util:encrypt_config_file(SrcFileName, EncryptFileName, KeyOrFile). + +%%%----------------------------------------------------------------- +%%% @spec decrypt_config_file(EncryptFileName, TargetFileName) -> +%%% ok | {error,Reason} +%%% EncryptFileName = string() +%%% TargetFileName = string() +%%% Reason = term() +%%% +%%% @doc <p>This function decrypts <code>EncryptFileName</code>, previously +%%% generated with <code>encrypt_config_file/2/3</code>. The original +%%% file contents is saved in the target file. The encryption key, a +%%% string, must be available in a text file named +%%% <code>.ct_config.crypt</code> in the current directory, or the +%%% home directory of the user (it is searched for in that order).</p> +decrypt_config_file(EncryptFileName, TargetFileName) -> + ct_util:decrypt_config_file(EncryptFileName, TargetFileName). + +%%%----------------------------------------------------------------- +%%% @spec decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile) -> +%%% ok | {error,Reason} +%%% EncryptFileName = string() +%%% TargetFileName = string() +%%% KeyOrFile = {key,string()} | {file,string()} +%%% Reason = term() +%%% +%%% @doc <p>This function decrypts <code>EncryptFileName</code>, previously +%%% generated with <code>encrypt_config_file/2/3</code>. The original +%%% file contents is saved in the target file. The key must have the +%%% the same value as that used for encryption.</p> +decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile) -> + ct_util:decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile). + diff --git a/lib/common_test/src/ct_cover.erl b/lib/common_test/src/ct_cover.erl new file mode 100644 index 0000000000..d39f50ba00 --- /dev/null +++ b/lib/common_test/src/ct_cover.erl @@ -0,0 +1,368 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework code coverage support module. +%%% +%%% <p>This module exports help functions for performing code +%%% coverage analysis.</p> + +-module(ct_cover). + +-export([get_spec/1, add_nodes/1, remove_nodes/1]). + +-include("ct_util.hrl"). + +-include_lib("kernel/include/file.hrl"). + +%%%----------------------------------------------------------------- +%%% @spec add_nodes(Nodes) -> {ok,StartedNodes} | {error,Reason} +%%% Nodes = [atom()] +%%% StartedNodes = [atom()] +%%% Reason = cover_not_running | not_main_node +%%% +%%% @doc Add nodes to current cover test (only works if cover support +%%% is active!). To have effect, this function should be called +%%% from init_per_suite/1 before any actual tests are performed. +%%% +add_nodes([]) -> + {ok,[]}; +add_nodes(Nodes) -> + case whereis(cover_server) of + undefined -> + {error,cover_not_running}; + _ -> + {File,Nodes0,Import,Export,AppInfo} = ct_util:get_testdata(cover), + Nodes1 = [Node || Node <- Nodes, + lists:member(Node,Nodes0) == false], + ct_logs:log("COVER INFO", + "Adding nodes to cover test: ~w", [Nodes1]), + case cover:start(Nodes1) of + Result = {ok,_} -> + ct_util:set_testdata({cover,{File,Nodes1++Nodes0, + Import,Export,AppInfo}}), + + Result; + Error -> + Error + end + end. + + +%%%----------------------------------------------------------------- +%%% @spec remove_nodes(Nodes) -> ok | {error,Reason} +%%% Nodes = [atom()] +%%% Reason = cover_not_running | not_main_node +%%% +%%% @doc Remove nodes from current cover test. Call this function +%%% to stop cover test on nodes previously added with add_nodes/1. +%%% Results on the remote node are transferred to the Common Test +%%% node. +%%% +remove_nodes([]) -> + ok; +remove_nodes(Nodes) -> + case whereis(cover_server) of + undefined -> + {error,cover_not_running}; + _ -> + {File,Nodes0,Import,Export,AppInfo} = ct_util:get_testdata(cover), + ToRemove = [Node || Node <- Nodes, lists:member(Node,Nodes0)], + ct_logs:log("COVER INFO", + "Removing nodes from cover test: ~w", [ToRemove]), + case cover:stop(ToRemove) of + ok -> + Nodes1 = lists:foldl(fun(N,Deleted) -> + lists:delete(N,Deleted) + end, Nodes0, ToRemove), + ct_util:set_testdata({cover,{File,Nodes1, + Import,Export,AppInfo}}), + ok; + Error -> + Error + end + end. + + +%%%----------------------------------------------------------------- +%%% @hidden + +%% Read cover specification file and return the parsed info. +%% -> CoverSpec: {CoverFile,Nodes,Import,Export,AppCoverInfo} +get_spec(File) -> + catch get_spec_test(File). + +get_spec_test(File) -> + FullName = filename:absname(File), + case filelib:is_file(FullName) of + true -> + case file:consult(FullName) of + {ok,Terms} -> + Import = + case lists:keysearch(import, 1, Terms) of + {value,{_,Imps=[S|_]}} when is_list(S) -> + ImpsFN = lists:map(fun(F) -> + filename:absname(F) + end, Imps), + test_files(ImpsFN, ImpsFN); + {value,{_,Imp=[IC|_]}} when is_integer(IC) -> + ImpFN = filename:absname(Imp), + test_files([ImpFN], [ImpFN]); + _ -> + [] + end, + Export = + case lists:keysearch(export, 1, Terms) of + {value,{_,Exp=[EC|_]}} when is_integer(EC) -> + filename:absname(Exp); + {value,{_,[Exp]}} -> + filename:absname(Exp); + _ -> + [] + end, + Nodes = + case lists:keysearch(nodes, 1, Terms) of + {value,{_,Ns}} -> + Ns; + _ -> + [] + end, + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + %% NOTE! We can read specifications with multiple %% + %% apps, but since we don't have support for %% + %% running cover on more than one app at a time, %% + %% we just allow 1 app per spec for now. %% + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + case collect_apps(Terms, []) of + Res when Res == [] ; length(Res) == 1 -> % 1 app = ok + Apps = case Res of + [] -> [#cover{app=none, level=details}]; + _ -> Res + end, + case get_cover_opts(Apps, Terms, []) of + E = {error,_} -> + E; + [CoverSpec] -> + CoverSpec1 = remove_excludes_and_dups(CoverSpec), + {FullName,Nodes,Import,Export,CoverSpec1}; + _ -> + {error,multiple_apps_in_cover_spec} + end; + Apps when is_list(Apps) -> + {error,multiple_apps_in_cover_spec} + end; + Error -> % file:consult/1 fails + {error,{invalid_cover_spec,Error}} + end; + false -> + {error,{cant_read_cover_spec_file,FullName}} + end. + +collect_apps([{level,Level}|Ts], Apps) -> + collect_apps(Ts, [#cover{app=none, level=Level}|Apps]); +collect_apps([{incl_app,App,Level}|Ts], Apps) -> + collect_apps(Ts, [#cover{app=App, level=Level}|Apps]); +collect_apps([_|Ts], Apps) -> + collect_apps(Ts, Apps); +collect_apps([], Apps) -> + Apps. + +%% get_cover_opts(Terms) -> AppCoverInfo +%% AppCoverInfo: [#cover{app=App,...}] + +get_cover_opts([App | Apps], Terms, CoverInfo) -> + case get_app_info(App, Terms) of + E = {error,_} -> E; + AppInfo -> + AppInfo1 = files2mods(AppInfo), + get_cover_opts(Apps, Terms, [AppInfo1|CoverInfo]) + end; +get_cover_opts([], _, CoverInfo) -> + lists:reverse(CoverInfo). + +%% get_app_info(App, Terms) -> App1 + +get_app_info(App=#cover{app=none}, [{incl_dirs,Dirs}|Terms]) -> + get_app_info(App, [{incl_dirs,none,Dirs}|Terms]); +get_app_info(App=#cover{app=Name}, [{incl_dirs,Name,Dirs}|Terms]) -> + case get_files(Dirs, ".beam", false, []) of + E = {error,_} -> E; + Mods1 -> + Mods = App#cover.incl_mods, + get_app_info(App#cover{incl_mods=Mods++Mods1},Terms) + end; + +get_app_info(App=#cover{app=none}, [{incl_dirs_r,Dirs}|Terms]) -> + get_app_info(App, [{incl_dirs_r,none,Dirs}|Terms]); +get_app_info(App=#cover{app=Name}, [{incl_dirs_r,Name,Dirs}|Terms]) -> + case get_files(Dirs, ".beam", true, []) of + E = {error,_} -> E; + Mods1 -> + Mods = App#cover.incl_mods, + get_app_info(App#cover{incl_mods=Mods++Mods1},Terms) + end; + +get_app_info(App=#cover{app=none}, [{incl_mods,Mods1}|Terms]) -> + get_app_info(App, [{incl_mods,none,Mods1}|Terms]); +get_app_info(App=#cover{app=Name}, [{incl_mods,Name,Mods1}|Terms]) -> + Mods = App#cover.incl_mods, + get_app_info(App#cover{incl_mods=Mods++Mods1},Terms); + +get_app_info(App=#cover{app=none}, [{excl_dirs,Dirs}|Terms]) -> + get_app_info(App, [{excl_dirs,none,Dirs}|Terms]); +get_app_info(App=#cover{app=Name}, [{excl_dirs,Name,Dirs}|Terms]) -> + case get_files(Dirs, ".beam", false, []) of + E = {error,_} -> E; + Mods1 -> + Mods = App#cover.excl_mods, + get_app_info(App#cover{excl_mods=Mods++Mods1},Terms) + end; + +get_app_info(App=#cover{app=none}, [{excl_dirs_r,Dirs}|Terms]) -> + get_app_info(App, [{excl_dirs_r,none,Dirs}|Terms]); +get_app_info(App=#cover{app=Name}, [{excl_dirs_r,Name,Dirs}|Terms]) -> + case get_files(Dirs, ".beam", true, []) of + E = {error,_} -> E; + Mods1 -> + Mods = App#cover.excl_mods, + get_app_info(App#cover{excl_mods=Mods++Mods1},Terms) + end; + +get_app_info(App=#cover{app=none}, [{excl_mods,Mods1}|Terms]) -> + get_app_info(App, [{excl_mods,none,Mods1}|Terms]); +get_app_info(App=#cover{app=Name}, [{excl_mods,Name,Mods1}|Terms]) -> + Mods = App#cover.excl_mods, + get_app_info(App#cover{excl_mods=Mods++Mods1},Terms); + +get_app_info(App=#cover{app=Name}, [{cross_apps,Name,AppMods1}|Terms]) -> + AppMods = App#cover.cross, + get_app_info(App#cover{cross=AppMods++AppMods1},Terms); + +get_app_info(App=#cover{app=none}, [{src_dirs,Dirs}|Terms]) -> + get_app_info(App, [{src_dirs,none,Dirs}|Terms]); +get_app_info(App=#cover{app=Name}, [{src_dirs,Name,Dirs}|Terms]) -> + case get_files(Dirs, ".erl", false, []) of + E = {error,_} -> E; + Src1 -> + Src = App#cover.src, + get_app_info(App#cover{src=Src++Src1},Terms) + end; + +get_app_info(App=#cover{app=none}, [{src_dirs_r,Dirs}|Terms]) -> + get_app_info(App, [{src_dirs_r,none,Dirs}|Terms]); +get_app_info(App=#cover{app=Name}, [{src_dirs_r,Name,Dirs}|Terms]) -> + case get_files(Dirs, ".erl", true, []) of + E = {error,_} -> E; + Src1 -> + Src = App#cover.src, + get_app_info(App#cover{src=Src++Src1},Terms) + end; + +get_app_info(App=#cover{app=none}, [{src_files,Src1}|Terms]) -> + get_app_info(App, [{src_files,none,Src1}|Terms]); +get_app_info(App=#cover{app=Name}, [{src_files,Name,Src1}|Terms]) -> + Src = App#cover.src, + get_app_info(App#cover{src=Src++Src1},Terms); + +get_app_info(App, [_|Terms]) -> + get_app_info(App, Terms); + +get_app_info(App, []) -> + App. + +%% get_files(...) + +get_files([Dir|Dirs], Ext, Recurse, Files) -> + case file:list_dir(Dir) of + {ok,Entries} -> + {SubDirs,Matches} = analyse_files(Entries, Dir, Ext, [], []), + if Recurse == false -> + get_files(Dirs, Ext, Recurse, Files++Matches); + true -> + Files1 = get_files(SubDirs, Ext, Recurse, Files++Matches), + get_files(Dirs, Ext, Recurse, Files1) + end; + {error,Reason} -> + {error,{Reason,Dir}} + end; +get_files([], _Ext, _R, Files) -> + Files. + +%% analyse_files(...) + +analyse_files([F|Fs], Dir, Ext, Dirs, Matches) -> + Fullname = filename:absname(F, Dir), + {ok,Info} = file:read_file_info(Fullname), + case Info#file_info.type of + directory -> + analyse_files(Fs, Dir, Ext, + [Fullname|Dirs], Matches); + _ -> + case filename:extension(Fullname) of + ".beam" when Ext == ".beam" -> + %% File = {file,Dir,filename:rootname(F)}, + Mod = list_to_atom(filename:rootname(F)), + analyse_files(Fs, Dir, Ext, Dirs, + [Mod|Matches]); + ".erl" when Ext == ".erl" -> + analyse_files(Fs, Dir, Ext, Dirs, + [Fullname|Matches]); + _ -> + analyse_files(Fs, Dir, Ext, Dirs, Matches) + end + end; +analyse_files([], _Dir, _Ext, Dirs, Matches) -> + {Dirs,Matches}. + + +test_files([F|Fs], Ret) -> + case filelib:is_file(F) of + true -> + test_files(Fs, Ret); + false -> + throw({error,{invalid_cover_file,F}}) + end; +test_files([], Ret) -> + Ret. + +remove_excludes_and_dups(CoverData=#cover{excl_mods=Excl,incl_mods=Incl}) -> + Incl1 = [Mod || Mod <- Incl, lists:member(Mod, Excl) == false], + %% delete duplicates and sort + Incl2 = lists:sort(lists:foldl(fun(M,L) -> + case lists:member(M,L) of + true -> L; + false -> [M|L] + end + end, [], Incl1)), + CoverData#cover{incl_mods=Incl2}. + + +files2mods(Info=#cover{excl_mods=ExclFs, + incl_mods=InclFs, + cross=CrossFs}) -> + Info#cover{excl_mods=files2mods1(ExclFs), + incl_mods=files2mods1(InclFs), + cross=files2mods1(CrossFs)}. + +files2mods1([M|Fs]) when is_atom(M) -> + [M|files2mods1(Fs)]; +files2mods1([F|Fs]) when is_list(F) -> + M = filename:rootname(filename:basename(F)), + [list_to_atom(M)|files2mods1(Fs)]; +files2mods1([]) -> + []. diff --git a/lib/common_test/src/ct_event.erl b/lib/common_test/src/ct_event.erl new file mode 100644 index 0000000000..3e79898ad1 --- /dev/null +++ b/lib/common_test/src/ct_event.erl @@ -0,0 +1,269 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework Event Handler +%%% +%%% <p>This module implements an event handler that CT uses to +%%% handle status and progress notifications during test runs. +%%% The notifications are handled locally (per node) and passed +%%% on to ct_master when CT runs in distributed mode. This +%%% module may be used as a template for other event handlers +%%% that can be plugged in to handle local logging and reporting.</p> +-module(ct_event). + +-behaviour(gen_event). + +%% API +-export([start_link/0, add_handler/0, add_handler/1, stop/0]). +-export([notify/1, sync_notify/1]). +-export([is_alive/0]). + +%% gen_event callbacks +-export([init/1, handle_event/2, handle_call/2, + handle_info/2, terminate/2, code_change/3]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). + +%% receivers = [{RecvTag,Pid}] +-record(state, {receivers=[]}). + + +%%==================================================================== +%% gen_event callbacks +%%==================================================================== + +%%-------------------------------------------------------------------- +%% Function: start_link() -> {ok,Pid} | {error,Error} +%% Description: Creates an event manager. +%%-------------------------------------------------------------------- +start_link() -> + gen_event:start_link({local,?CT_EVMGR}). + +%%-------------------------------------------------------------------- +%% Function: add_handler() -> ok | {'EXIT',Reason} | term() +%% Description: Adds an event handler +%%-------------------------------------------------------------------- +add_handler() -> + gen_event:add_handler(?CT_EVMGR_REF,?MODULE,[]). +add_handler(Args) -> + gen_event:add_handler(?CT_EVMGR_REF,?MODULE,Args). + +%%-------------------------------------------------------------------- +%% Function: stop() -> ok +%% Description: Stops the event manager +%%-------------------------------------------------------------------- +stop() -> + case whereis(?CT_EVMGR) of + undefined -> + ok; + _Pid -> + gen_event:stop(?CT_EVMGR_REF) + end. + +%%-------------------------------------------------------------------- +%% Function: notify(Event) -> ok +%% Description: Asynchronous notification to event manager. +%%-------------------------------------------------------------------- +notify(Event) -> + case catch gen_event:notify(?CT_EVMGR_REF,Event) of + {'EXIT',Reason} -> + {error,{notify,Reason}}; + Result -> + Result + end. + +%%-------------------------------------------------------------------- +%% Function: sync_notify(Event) -> ok +%% Description: Synchronous notification to event manager. +%%-------------------------------------------------------------------- +sync_notify(Event) -> + case catch gen_event:sync_notify(?CT_EVMGR_REF,Event) of + {'EXIT',Reason} -> + {error,{sync_notify,Reason}}; + Result -> + Result + end. + +%%-------------------------------------------------------------------- +%% Function: is_alive() -> true | false +%% Description: Check if Event Manager is alive. +%%-------------------------------------------------------------------- +is_alive() -> + case whereis(?CT_EVMGR) of + undefined -> + false; + _Pid -> + true + end. + +%%==================================================================== +%% gen_event callbacks +%%==================================================================== +%%-------------------------------------------------------------------- +%% Function: init(Args) -> {ok, State} +%% Description: Whenever a new event handler is added to an event manager, +%% this function is called to initialize the event handler. +%%-------------------------------------------------------------------- +init(RecvPids) -> + %% RecvPids = [{RecvTag,Pid}] + {ok,#state{receivers=RecvPids}}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_event(Event, State) -> {ok, State} | +%% {swap_handler, Args1, State1, Mod2, Args2} | +%% remove_handler +%% Description:Whenever an event manager receives an event sent using +%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for +%% each installed event handler to handle the event. +%%-------------------------------------------------------------------- +handle_event(Event,State=#state{receivers=RecvPids}) -> + print("~n=== ~w ===~n", [?MODULE]), + print("~p: ~p~n", [Event#event.name,Event#event.data]), + lists:foreach(fun(Recv) -> report_event(Recv,Event) end, RecvPids), + {ok,State}. + +%%============================== EVENTS ============================== +%% +%% Name = test_start +%% Data = {StartTime,LogDir} +%% +%% Name = start_info +%% Data = {Tests,Suites,Cases} +%% Tests = Suites = Cases = integer() +%% +%% Name = test_done +%% Data = EndTime +%% +%% Name = start_make +%% Data = Dir +%% +%% Name = finished_make +%% Data = Dir +%% +%% Name = tc_start +%% Data = {Suite,CaseOrGroup} +%% CaseOrGroup = atom() | {Conf,GroupName,GroupProperties} +%% Conf = init_per_group | end_per_group +%% GroupName = atom() +%% GroupProperties = list() +%% +%% Name = tc_done +%% Data = {Suite,CaseOrGroup,Result} +%% CaseOrGroup = atom() | {Conf,GroupName,GroupProperties} +%% Conf = init_per_group | end_per_group +%% GroupName = atom() +%% GroupProperties = list() +%% Result = ok | {skipped,Reason} | {failed,Reason} +%% +%% Name = tc_user_skip +%% Data = {Suite,Case,Comment} +%% Comment = string() +%% +%% Name = tc_auto_skip +%% Data = {Suite,Case,Comment} +%% Comment = string() +%% +%% Name = test_stats +%% Data = {Ok,Failed,Skipped} +%% Ok = Failed = integer() +%% Skipped = {UserSkipped,AutoSkipped} +%% UserSkipped = AutoSkipped = integer() +%% +%% Name = start_logging +%% Data = CtRunDir +%% +%% Name = stop_logging +%% Data = [] +%% +%% Name = start_write_file +%% Data = FullNameFile +%% +%% Name = finished_write_file +%% Data = FullNameFile +%% +%% Name = +%% Data = +%% + +%% report to master +report_event({master,Master},E=#event{name=_Name,node=_Node,data=_Data}) -> + ct_master:status(Master,E); + +%% report to VTS +report_event({vts,VTS},#event{name=Name,node=_Node,data=Data}) -> + if Name == start_info ; + Name == test_stats ; + Name == test_done -> + vts:test_info(VTS,Name,Data); + true -> + ok + end. + + +%%-------------------------------------------------------------------- +%% Function: +%% handle_call(Request, State) -> {ok, Reply, State} | +%% {swap_handler, Reply, Args1, State1, +%% Mod2, Args2} | +%% {remove_handler, Reply} +%% Description: Whenever an event manager receives a request sent using +%% gen_event:call/3,4, this function is called for the specified event +%% handler to handle the request. +%%-------------------------------------------------------------------- +handle_call(_Req, State) -> + Reply = ok, + {ok, Reply, State}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_info(Info, State) -> {ok, State} | +%% {swap_handler, Args1, State1, Mod2, Args2} | +%% remove_handler +%% Description: This function is called for each installed event handler when +%% an event manager receives any other message than an event or a synchronous +%% request (or a system message). +%%-------------------------------------------------------------------- +handle_info(_Info, State) -> + {ok, State}. + +%%-------------------------------------------------------------------- +%% Function: terminate(Reason, State) -> void() +%% Description:Whenever an event handler is deleted from an event manager, +%% this function is called. It should be the opposite of Module:init/1 and +%% do any necessary cleaning up. +%%-------------------------------------------------------------------- +terminate(_Reason, _State) -> + ok. + +%%-------------------------------------------------------------------- +%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState} +%% Description: Convert process state when code is changed +%%-------------------------------------------------------------------- +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +%%-------------------------------------------------------------------- +%%% Internal functions +%%-------------------------------------------------------------------- + +print(_Str,_Args) -> +% io:format(_Str,_Args), + ok. diff --git a/lib/common_test/src/ct_framework.erl b/lib/common_test/src/ct_framework.erl new file mode 100644 index 0000000000..8456251b29 --- /dev/null +++ b/lib/common_test/src/ct_framework.erl @@ -0,0 +1,1059 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework callback module. +%%% +%%% <p>This module exports framework callback functions which are +%%% called from the test_server.</p> + +-module(ct_framework). + +-export([init_tc/3, end_tc/3, get_suite/2, report/2, warn/1]). +-export([error_notification/4]). + +-export([error_in_suite/1]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). + +%%%----------------------------------------------------------------- +%%% @spec init_tc(Mod,Func,Args) -> {ok,NewArgs} | {error,Reason} | +%%% {skip,Reason} | {auto_skip,Reason} +%%% Mod = atom() +%%% Func = atom() +%%% Args = list() +%%% NewArgs = list() +%%% Reason = term() +%%% +%%% @doc Test server framework callback, called by the test_server +%%% when a new test case is started. +init_tc(Mod,Func,Config) -> + %% check if previous testcase was interpreted and has left + %% a "dead" trace window behind - if so, kill it + case ct_util:get_testdata(interpret) of + {What,kill,{TCPid,AttPid}} -> + ct_util:kill_attached(TCPid,AttPid), + ct_util:set_testdata({interpret,{What,kill,{undefined,undefined}}}); + _ -> + ok + end, + + %% check if we need to add defaults explicitly because + %% there's no init_per_suite exported from Mod + {InitFailed,DoInit} = + case ct_util:get_testdata(curr_tc) of + {Mod,{suite0_failed,_}=Failure} -> + {Failure,false}; + {Mod,_} -> + {false,false}; + _ when Func == init_per_suite -> + {false,false}; + _ -> + {false,true} + end, + case InitFailed of + false -> + ct_util:set_testdata({curr_tc,{Mod,Func}}), + case ct_util:read_suite_data({seq,Mod,Func}) of + undefined -> + init_tc1(Mod,Func,Config,DoInit); + Seq when is_atom(Seq) -> + case ct_util:read_suite_data({seq,Mod,Seq}) of + [Func|TCs] -> % this is the 1st case in Seq + %% make sure no cases in this seq are marked as failed + %% from an earlier execution in the same suite + lists:foreach(fun(TC) -> + ct_util:save_suite_data({seq,Mod,TC},Seq) + end, TCs); + _ -> + ok + end, + init_tc1(Mod,Func,Config,DoInit); + {failed,Seq,BadFunc} -> + {skip,{sequence_failed,Seq,BadFunc}} + end; + {_,{require,Reason}} -> + {skip,{require_failed_in_suite0,Reason}}; + _ -> + {skip,InitFailed} + end. + +init_tc1(Mod,Func,[Config0],DoInit) when is_list(Config0) -> + Config1 = + case ct_util:read_suite_data(last_saved_config) of + {{Mod,LastFunc},SavedConfig} -> % last testcase + [{saved_config,{LastFunc,SavedConfig}} | + lists:keydelete(saved_config,1,Config0)]; + {{LastSuite,InitOrEnd},SavedConfig} when InitOrEnd == init_per_suite ; + InitOrEnd == end_per_suite -> % last suite + [{saved_config,{LastSuite,SavedConfig}} | + lists:keydelete(saved_config,1,Config0)]; + undefined -> + lists:keydelete(saved_config,1,Config0) + end, + ct_util:delete_suite_data(last_saved_config), + Config = lists:keydelete(watchdog,1,Config1), + if Func /= init_per_suite, DoInit /= true -> + ok; + true -> + %% delete all default values used in previous suite + ct_util:delete_default_config(suite), + %% release all name -> key bindings (once per suite) + ct_util:release_allocated() + end, + TestCaseInfo = + case catch apply(Mod,Func,[]) of + Result when is_list(Result) -> Result; + _ -> [] + end, + %% clear all config data default values set by previous + %% testcase info function (these should only survive the + %% testcase, not the whole suite) + ct_util:delete_default_config(testcase), + case add_defaults(Mod,Func,TestCaseInfo,DoInit) of + Error = {suite0_failed,_} -> + ct_logs:init_tc(), + FuncSpec = group_or_func(Func,Config0), + ct_event:notify(#event{name=tc_start, + node=node(), + data={Mod,FuncSpec}}), + ct_util:set_testdata({curr_tc,{Mod,Error}}), + {error,Error}; + {SuiteInfo,MergeResult} -> + case MergeResult of + {error,Reason} when DoInit == false -> + ct_logs:init_tc(), + FuncSpec = group_or_func(Func,Config0), + ct_event:notify(#event{name=tc_start, + node=node(), + data={Mod,FuncSpec}}), + {skip,Reason}; + _ -> + init_tc2(Mod,Func,SuiteInfo,MergeResult,Config,DoInit) + end + end; +init_tc1(_Mod,_Func,Args,_DoInit) -> + {ok,Args}. + +init_tc2(Mod,Func,SuiteInfo,MergeResult,Config,DoInit) -> + %% if first testcase fails when there's no init_per_suite + %% we must do suite/0 configurations before skipping test + MergedInfo = + case MergeResult of + {error,_} when DoInit == true -> + SuiteInfo; + _ -> + MergeResult + end, + %% timetrap must be handled before require + MergedInfo1 = timetrap_first(MergedInfo, [], []), + %% tell logger to use specified style sheet + case lists:keysearch(stylesheet,1,MergedInfo++Config) of + {value,{stylesheet,SSFile}} -> + ct_logs:set_stylesheet(Func,add_data_dir(SSFile,Config)); + _ -> + case ct_util:get_testdata(stylesheet) of + undefined -> + ct_logs:clear_stylesheet(Func); + SSFile -> + ct_logs:set_stylesheet(Func,SSFile) + end + end, + %% suppress output for connections (Conns is a + %% list of {Type,Bool} tuples, e.g. {telnet,true}), + case ct_util:get_overridden_silenced_connections() of + undefined -> + case lists:keysearch(silent_connections,1,MergedInfo++Config) of + {value,{silent_connections,Conns}} -> + ct_util:silence_connections(Conns); + _ -> + ok + end; + Conns -> + ct_util:silence_connections(Conns) + end, + + ct_logs:init_tc(), + FuncSpec = group_or_func(Func,Config), + ct_event:notify(#event{name=tc_start, + node=node(), + data={Mod,FuncSpec}}), + + case configure(MergedInfo1,MergedInfo1,SuiteInfo,{Func,DoInit},Config) of + {suite0_failed,Reason} -> + ct_util:set_testdata({curr_tc,{Mod,{suite0_failed,{require,Reason}}}}), + {skip,{require_failed_in_suite0,Reason}}; + {error,Reason} -> + {auto_skip,{require_failed,Reason}}; + FinalConfig -> + case MergeResult of + {error,Reason} -> + %% suite0 configure finished now, report that + %% first test case actually failed + {skip,Reason}; + _ -> + case get('$test_server_framework_test') of + undefined -> + FinalConfig; + Fun -> + Fun(init_tc, FinalConfig) + end + end + end. + + +add_defaults(Mod,Func,FuncInfo,DoInit) -> + case (catch Mod:suite()) of + {'EXIT',{undef,_}} -> + SuiteInfo = merge_with_suite_defaults(Mod,[]), + case add_defaults1(Mod,Func,FuncInfo,SuiteInfo,DoInit) of + Error = {error,_} -> {SuiteInfo,Error}; + MergedInfo -> {SuiteInfo,MergedInfo} + end; + {'EXIT',Reason} -> + {suite0_failed,{exited,Reason}}; + SuiteInfo when is_list(SuiteInfo) -> + case lists:all(fun(E) when is_tuple(E) -> true; + (_) -> false + end, SuiteInfo) of + true -> + SuiteInfo1 = merge_with_suite_defaults(Mod,SuiteInfo), + case add_defaults1(Mod,Func,FuncInfo,SuiteInfo1,DoInit) of + Error = {error,_} -> {SuiteInfo1,Error}; + MergedInfo -> {SuiteInfo1,MergedInfo} + end; + false -> + {suite0_failed,bad_return_value} + end; + _ -> + {suite0_failed,bad_return_value} + end. + +add_defaults1(_Mod,init_per_suite,[],SuiteInfo,_) -> + SuiteInfo; + +add_defaults1(Mod,Func,FuncInfo,SuiteInfo,DoInit) -> + %% mustn't re-require suite variables in test case info function, + %% can result in weird behaviour (suite values get overwritten) + SuiteReqs = + [SDDef || SDDef <- SuiteInfo, + require == element(1,SDDef)], + case [element(2,Clash) || Clash <- SuiteReqs, + true == lists:keymember(element(2,Clash),2,FuncInfo)] of + [] -> + add_defaults2(Mod,Func,FuncInfo,SuiteInfo,SuiteReqs,DoInit); + Clashes -> + {error,{config_name_already_in_use,Clashes}} + end. + +add_defaults2(_Mod,_Func,FuncInfo,SuiteInfo,_,false) -> + %% include require elements from test case info, but not from suite/0 + %% (since we've already required those vars) + FuncInfo ++ + [SFDef || SFDef <- SuiteInfo, + require /= element(1,SFDef), + false == lists:keymember(element(1,SFDef),1,FuncInfo)]; + +add_defaults2(_Mod,_Func,FuncInfo,SuiteInfo,SuiteReqs,true) -> + %% We must include require elements from suite/0 here since + %% there's no init_per_suite call before this first test case. + %% Let other test case info elements override those from suite/0. + FuncInfo ++ SuiteReqs ++ + [SDDef || SDDef <- SuiteInfo, + require /= element(1,SDDef), + false == lists:keymember(element(1,SDDef),1,FuncInfo)]. + +merge_with_suite_defaults(Mod,SuiteInfo) -> + case lists:keysearch(suite_defaults,1,Mod:module_info(attributes)) of + {value,{suite_defaults,Defaults}} -> + SDReqs = + [SDDef || SDDef <- Defaults, + require == element(1,SDDef), + false == lists:keymember(element(2,SDDef),2, + SuiteInfo)], + SuiteInfo ++ SDReqs ++ + [SDDef || SDDef <- Defaults, + require /= element(1,SDDef), + false == lists:keymember(element(1,SDDef),1, + SuiteInfo)]; + false -> + SuiteInfo + end. + +timetrap_first([Trap = {timetrap,_} | Rest],Info,Found) -> + timetrap_first(Rest,Info,[Trap | Found]); +timetrap_first([Other | Rest],Info,Found) -> + timetrap_first(Rest,[Other | Info],Found); +timetrap_first([],Info,[]) -> + [{timetrap,{minutes,30}} | lists:reverse(Info)]; +timetrap_first([],Info,Found) -> + lists:reverse(Found) ++ lists:reverse(Info). + +configure([{require,Required}|Rest],Info,SuiteInfo,Scope,Config) -> + case ct:require(Required) of + ok -> + configure(Rest,Info,SuiteInfo,Scope,Config); + Error = {error,Reason} -> + case required_default('_UNDEF',Required,Info,SuiteInfo,Scope) of + ok -> + configure(Rest,Info,SuiteInfo,Scope,Config); + _ -> + case lists:keymember(Required,2,SuiteInfo) of + true -> + {suite0_failed,Reason}; + false -> + Error + end + end + end; +configure([{require,Name,Required}|Rest],Info,SuiteInfo,Scope,Config) -> + case ct:require(Name,Required) of + ok -> + configure(Rest,Info,SuiteInfo,Scope,Config); + Error = {error,Reason} -> + case required_default(Name,Required,Info,SuiteInfo,Scope) of + ok -> + configure(Rest,Info,SuiteInfo,Scope,Config); + _ -> + case lists:keymember(Name,2,SuiteInfo) of + true -> + {suite0_failed,Reason}; + false -> + Error + end + end + end; +configure([{timetrap,off}|Rest],Info,SuiteInfo,Scope,Config) -> + configure(Rest,Info,SuiteInfo,Scope,Config); +configure([{timetrap,Time}|Rest],Info,SuiteInfo,Scope,Config) -> + Dog = test_server:timetrap(Time), + configure(Rest,Info,SuiteInfo,Scope,[{watchdog,Dog}|Config]); +configure([_|Rest],Info,SuiteInfo,Scope,Config) -> + configure(Rest,Info,SuiteInfo,Scope,Config); +configure([],_,_,_,Config) -> + {ok,[Config]}. + +%% the require element in Info may come from suite/0 and +%% should be scoped 'suite', or come from the testcase info +%% function and should then be scoped 'testcase' +required_default(Name,Key,Info,SuiteInfo,{Func,true}) -> + case try_set_default(Name,Key,SuiteInfo,suite) of + ok -> + ok; + _ -> + required_default(Name,Key,Info,[],{Func,false}) + end; +required_default(Name,Key,Info,_,{init_per_suite,_}) -> + try_set_default(Name,Key,Info,suite); +required_default(Name,Key,Info,_,_) -> + try_set_default(Name,Key,Info,testcase). + +try_set_default(Name,Key,Info,Where) -> + CfgElems = + case lists:keysearch(Name,1,Info) of + {value,{Name,Val}} -> + [Val]; + false -> + case catch [{Key,element(3,Elem)} || Elem <- Info, + element(1,Elem)==default_config, + element(2,Elem)==Key] of + {'EXIT',_} -> []; + Result -> Result + end + end, + case {Name,CfgElems} of + {_,[]} -> + no_default; + {'_UNDEF',_} -> + [ct_util:set_default_config([CfgVal],Where) || CfgVal <- CfgElems], + ok; + _ -> + [ct_util:set_default_config(Name,[CfgVal],Where) || CfgVal <- CfgElems], + ok + end. + + +%%%----------------------------------------------------------------- +%%% @spec end_tc(Mod,Func,Args) -> {ok,NewArgs}| {error,Reason} | +%%% {skip,Reason} | {auto_skip,Reason} +%%% Mod = atom() +%%% Func = atom() +%%% Args = list() +%%% NewArgs = list() +%%% Reason = term() +%%% +%%% @doc Test server framework callback, called by the test_server +%%% when a test case is finished. +end_tc(?MODULE,error_in_suite,_) -> % bad start! + ok; +end_tc(Mod,Func,{TCPid,Result,[Args]}) when is_pid(TCPid) -> + end_tc(Mod,Func,TCPid,Result,Args); +end_tc(Mod,Func,{Result,[Args]}) -> + end_tc(Mod,Func,self(),Result,Args). + +end_tc(Mod,Func,TCPid,Result,Args) -> + case lists:keysearch(watchdog,1,Args) of + {value,{watchdog,Dog}} -> test_server:timetrap_cancel(Dog); + false -> ok + end, + + %% save the testcase process pid so that it can be used + %% to look up the attached trace window later + case ct_util:get_testdata(interpret) of + {What,kill,_} -> + AttPid = ct_util:get_attached(self()), + ct_util:set_testdata({interpret,{What,kill,{self(),AttPid}}}); + _ -> + ok + end, + + ct_util:delete_testdata(comment), + ct_util:delete_suite_data(last_saved_config), + FuncSpec = + case group_or_func(Func,Args) of + {_,GroupName,_Props} = Group -> + case lists:keysearch(save_config,1,Args) of + {value,{save_config,SaveConfig}} -> + ct_util:save_suite_data(last_saved_config, + {Mod,{group,GroupName}},SaveConfig), + Group; + false -> + Group + end; + _ -> + case lists:keysearch(save_config,1,Args) of + {value,{save_config,SaveConfig}} -> + ct_util:save_suite_data(last_saved_config, + {Mod,Func},SaveConfig), + Func; + false -> + Func + end + end, + ct_util:reset_silent_connections(), + + %% send sync notification so that event handlers may print + %% in the log file before it gets closed + ct_event:sync_notify(#event{name=tc_done, + node=node(), + data={Mod,FuncSpec,tag(Result)}}), + case Result of + {skip,{sequence_failed,_,_}} -> + %% ct_logs:init_tc is never called for a skipped test case + %% in a failing sequence, so neither should end_tc + ok; + _ -> + case ct_logs:end_tc(TCPid) of + {error,Reason} -> + exit({error,{logger,Reason}}); + _ -> + ok + end + end, + case Func of + end_per_suite -> + ct_util:match_delete_suite_data({seq,Mod,'_'}); + _ -> + ok + end, + case get('$test_server_framework_test') of + undefined -> + ok; + Fun -> + Fun(end_tc, ok) + end. + +%% {error,Reason} | {skip,Reason} | {timetrap_timeout,TVal} | +%% {testcase_aborted,Reason} | testcase_aborted_or_killed | +%% {'EXIT',Reason} | Other (ignored return value, e.g. 'ok') +tag({STag,Reason}) when STag == skip; STag == skipped -> + {skipped,Reason}; +tag(E = {ETag,_}) when ETag == error; ETag == 'EXIT'; + ETag == timetrap_timeout; + ETag == testcase_aborted -> + {failed,E}; +tag(E = testcase_aborted_or_killed) -> + {failed,E}; +tag(Other) -> + Other. + +%%%----------------------------------------------------------------- +%%% @spec error_notification(Mod,Func,Args,Error) -> ok +%%% Mod = atom() +%%% Func = atom() +%%% Args = list() +%%% Error = term() +%%% +%%% @doc This function is called as the result of testcase +%%% <code>Func</code> in suite <code>Mod</code> crashing. +%%% <code>Error</code> specifies the reason for failing. +error_notification(Mod,Func,_Args,{Error,Loc}) -> + ErrSpec = case Error of + {What={_E,_R},Trace} when is_list(Trace) -> + What; + What -> + What + end, + ErrStr = case ErrSpec of + {badmatch,Descr} -> + Descr1 = lists:flatten(io_lib:format("~P",[Descr,10])), + if length(Descr1) > 50 -> + Descr2 = string:substr(Descr1,1,50), + io_lib:format("{badmatch,~s...}",[Descr2]); + true -> + io_lib:format("{badmatch,~s}",[Descr1]) + end; + {test_case_failed,Reason} -> + case (catch io_lib:format("{test_case_failed,~s}", [Reason])) of + {'EXIT',_} -> + io_lib:format("{test_case_failed,~p}", [Reason]); + Result -> Result + end; + {Spec,_Reason} when is_atom(Spec) -> + io_lib:format("~w", [Spec]); + Other -> + io_lib:format("~P", [Other,5]) + end, + ErrorHtml = "<font color=\"brown\">" ++ ErrStr ++ "</font>", + case {Mod,Error} of + %% some notifications come from the main test_server process + %% and for these cases the existing comment may not be modified + {_,{timetrap_timeout,_TVal}} -> + ok; + {_,{testcase_aborted,_Info}} -> + ok; + {_,testcase_aborted_or_killed} -> + ok; + {undefined,_OtherError} -> + ok; + _ -> + %% this notification comes from the test case process, so + %% we can add error info to comment with test_server:comment/1 + case ct_util:get_testdata(comment) of + undefined -> + test_server:comment(ErrorHtml); + Comment -> + CommentHtml = + "<font color=\"green\">" ++ "(" ++ "</font>" + ++ Comment ++ + "<font color=\"green\">" ++ ")" ++ "</font>", + Str = io_lib:format("~s ~s", [ErrorHtml,CommentHtml]), + test_server:comment(Str) + end + end, + + io:format(user, "~n- - - - - - - - - - - - - - - - " + "- - - - - - - - - -~n", []), + case Loc of + %% we don't use the line parse transform as we compile this + %% module so location will be on form {M,F} + [{?MODULE,error_in_suite}] -> + io:format(user, "Error in suite detected: ~s", [ErrStr]); + + unknown -> + io:format(user, "Error detected: ~s", [ErrStr]); + + %% if a function specified by all/0 does not exist, we + %% pick up undef here + [{LastMod,LastFunc}] -> + io:format(user, "~w:~w could not be executed~n", + [LastMod,LastFunc]), + io:format(user, "Reason: ~s", [ErrStr]); + + [{LastMod,LastFunc,LastLine}|_] -> + %% print error to console, we are only + %% interested in the last executed expression + io:format(user, "~w:~w failed on line ~w~n", + [LastMod,LastFunc,LastLine]), + io:format(user, "Reason: ~s", [ErrStr]), + + case ct_util:read_suite_data({seq,Mod,Func}) of + undefined -> + ok; + Seq -> + SeqTCs = ct_util:read_suite_data({seq,Mod,Seq}), + mark_as_failed(Seq,Mod,Func,SeqTCs) + end + end, + io:format(user, "~n- - - - - - - - - - - - - - - - " + "- - - - - - - - - -~n~n", []), + ok. + +%% cases in seq that have already run +mark_as_failed(Seq,Mod,Func,[Func|TCs]) -> + mark_as_failed1(Seq,Mod,Func,TCs); +mark_as_failed(Seq,Mod,Func,[_TC|TCs]) -> + mark_as_failed(Seq,Mod,Func,TCs); +mark_as_failed(_,_,_,[]) -> + ok; +mark_as_failed(_,_,_,undefined) -> + ok. + +%% mark rest of cases in seq to be skipped +mark_as_failed1(Seq,Mod,Func,[TC|TCs]) -> + ct_util:save_suite_data({seq,Mod,TC},{failed,Seq,Func}), + mark_as_failed1(Seq,Mod,Func,TCs); +mark_as_failed1(_,_,_,[]) -> + ok. + +group_or_func(Func, Config) when Func == init_per_group; + Func == end_per_group -> + case proplists:get_value(tc_group_properties,Config) of + undefined -> + {Func,unknown,[]}; + GrProps -> + GrName = proplists:get_value(name,GrProps), + {Func,GrName,proplists:delete(name,GrProps)} + end; +group_or_func(Func, _Config) -> + Func. + +%%%----------------------------------------------------------------- +%%% @spec get_suite(Mod, Func) -> Tests +%%% +%%% @doc Called from test_server for every suite (<code>Func==all</code>) +%%% and every test case. If the former, all test cases in the suite +%%% should be returned. + +get_suite(Mod, all) -> + case catch apply(Mod, groups, []) of + {'EXIT',_} -> + get_all(Mod, []); + GroupDefs when is_list(GroupDefs) -> + case catch check_groups(Mod, GroupDefs) of + {error,_} = Error -> + %% this makes test_server call error_in_suite as first + %% (and only) test case so we can report Error properly + [{?MODULE,error_in_suite,[[Error]]}]; + ConfTests -> + get_all(Mod, ConfTests) + end; + _ -> + E = "Bad return value from "++atom_to_list(Mod)++":groups/0", + [{?MODULE,error_in_suite,[[{error,list_to_atom(E)}]]}] + end; + +%%!============================================================ +%%! Note: The handling of sequences in get_suite/2 and get_all/2 +%%! is deprecated and should be removed after OTP R13! +%%!============================================================ + +get_suite(Mod, Name) -> + %% Name may be name of a group or a test case. If it's a group, + %% it should be expanded to list of cases (in a conf term) + case catch apply(Mod, groups, []) of + {'EXIT',_} -> + get_seq(Mod, Name); + GroupDefs when is_list(GroupDefs) -> + case catch check_groups(Mod, GroupDefs) of + {error,_} = Error -> + %% this makes test_server call error_in_suite as first + %% (and only) test case so we can report Error properly + [{?MODULE,error_in_suite,[[Error]]}]; + ConfTests -> + FindConf = fun({conf,Props,_,_,_}) -> + case proplists:get_value(name, Props) of + Name -> true; + _ -> false + end + end, + case lists:filter(FindConf, ConfTests) of + [] -> % must be a test case + get_seq(Mod, Name); + [ConfTest|_] -> + ConfTest + end + end; + _ -> + E = "Bad return value from "++atom_to_list(Mod)++":groups/0", + [{?MODULE,error_in_suite,[[{error,list_to_atom(E)}]]}] + end. + +check_groups(_Mod, []) -> + []; +check_groups(Mod, Defs) -> + check_groups(Mod, Defs, Defs, []). + +check_groups(Mod, [TC | Gs], Defs, Levels) when is_atom(TC), length(Levels)>0 -> + [TC | check_groups(Mod, Gs, Defs, Levels)]; + +check_groups(Mod, [{group,SubName} | Gs], Defs, Levels) when is_atom(SubName) -> + case lists:member(SubName, Levels) of + true -> + E = "Cyclic reference to group "++atom_to_list(SubName)++ + " in "++atom_to_list(Mod)++":groups/0", + throw({error,list_to_atom(E)}); + false -> + case find_group(Mod, SubName, Defs) of + {error,_} = Error -> + throw(Error); + G -> + [check_groups(Mod, [G], Defs, Levels) | + check_groups(Mod, Gs, Defs, Levels)] + end + end; + +check_groups(Mod, [{Name,Tests} | Gs], Defs, Levels) when is_atom(Name), + is_list(Tests) -> + check_groups(Mod, [{Name,[],Tests} | Gs], Defs, Levels); + +check_groups(Mod, [{Name,Props,Tests} | Gs], Defs, Levels) when is_atom(Name), + is_list(Props), + is_list(Tests) -> + {TestSpec,Levels1} = + case Levels of + [] -> + {check_groups(Mod, Tests, Defs, [Name]),[]}; + _ -> + {check_groups(Mod, Tests, Defs, [Name|Levels]),Levels} + end, + [make_conf(Mod, Name, Props, TestSpec) | + check_groups(Mod, Gs, Defs, Levels1)]; + +check_groups(Mod, [BadTerm | _Gs], _Defs, Levels) -> + Where = if length(Levels) == 0 -> + atom_to_list(Mod)++":groups/0"; + true -> + "group "++atom_to_list(lists:last(Levels))++ + " in "++atom_to_list(Mod)++":groups/0" + end, + Term = io_lib:format("~p", [BadTerm]), + E = "Bad term "++lists:flatten(Term)++" in "++Where, + throw({error,list_to_atom(E)}); + +check_groups(_Mod, [], _Defs, _) -> + []. + +find_group(Mod, Name, Defs) -> + case lists:keysearch(Name, 1, Defs) of + {value,Def} -> + Def; + false -> + E = "Invalid group "++atom_to_list(Name)++ + " in "++atom_to_list(Mod)++":groups/0", + throw({error,list_to_atom(E)}) + end. + +make_conf(Mod, Name, Props, TestSpec) -> + {conf,[{name,Name}|Props], + {Mod,init_per_group},TestSpec,{Mod,end_per_group}}. + + +get_all(Mod, ConfTests) -> + case catch apply(Mod, all, []) of + {'EXIT',_} -> + Reason = + list_to_atom(atom_to_list(Mod)++":all/0 is missing"), + %% this makes test_server call error_in_suite as first + %% (and only) test case so we can report Reason properly + [{?MODULE,error_in_suite,[[{error,Reason}]]}]; + AllTCs when is_list(AllTCs) -> + case catch save_seqs(Mod,AllTCs) of + {error,What} -> + [{?MODULE,error_in_suite,[[{error,What}]]}]; + SeqsAndTCs -> + %% expand group references in all() using ConfTests + Expand = + fun({group,Name}) -> + FindConf = + fun({conf,Props,_,_,_}) -> + case proplists:get_value(name, Props) of + Name -> true; + _ -> false + end + end, + case lists:filter(FindConf, ConfTests) of + [ConfTest|_] -> + ConfTest; + [] -> + E = "Invalid reference to group "++ + atom_to_list(Name)++" in "++ + atom_to_list(Mod)++":all/0", + throw({error,list_to_atom(E)}) + end; + (SeqOrTC) -> SeqOrTC + end, + case catch lists:map(Expand, SeqsAndTCs) of + {error,_} = Error -> + [{?MODULE,error_in_suite,[[Error]]}]; + Tests -> + Tests + end + end; + Skip = {skip,_Reason} -> + Skip; + _ -> + Reason = + list_to_atom("Bad return value from "++atom_to_list(Mod)++":all/0"), + [{?MODULE,error_in_suite,[[{error,Reason}]]}] + end. + + +%%!============================================================ +%%! The support for sequences by means of using sequences/0 +%%! will be removed in OTP R14. The code below is only kept +%%! for backwards compatibility. From OTP R13 groups with +%%! sequence property should be used instead! +%%!============================================================ +%%!============================================================ +%%! START OF DEPRECATED SUPPORT FOR SEQUENCES ---> + +get_seq(Mod, Func) -> + case ct_util:read_suite_data({seq,Mod,Func}) of + undefined -> + case catch apply(Mod,sequences,[]) of + {'EXIT',_} -> + []; + Seqs -> + case lists:keysearch(Func,1,Seqs) of + {value,{Func,SeqTCs}} -> + case catch save_seq(Mod,Func,SeqTCs) of + {error,What} -> + [{?MODULE,error_in_suite,[[{error,What}]]}]; + _ -> + SeqTCs + end; + false -> + [] + end + end; + TCs when is_list(TCs) -> + TCs; + _ -> + [] + end. + +save_seqs(Mod,AllTCs) -> + case lists:keymember(sequence,1,AllTCs) of + true -> + case catch apply(Mod,sequences,[]) of + {'EXIT',_} -> + Reason = list_to_atom(atom_to_list(Mod)++ + ":sequences/0 is missing"), + throw({error,Reason}); + Seqs -> + save_seqs(Mod,AllTCs,Seqs,AllTCs) + end; + false -> + AllTCs + end. + +save_seqs(Mod,[{sequence,Seq}|TCs],Seqs,All) -> + case lists:keysearch(Seq,1,Seqs) of + {value,{Seq,SeqTCs}} -> + save_seq(Mod,Seq,SeqTCs,All), + [Seq|save_seqs(Mod,TCs,Seqs,All)]; + false -> + Reason = list_to_atom( + atom_to_list(Seq)++" is missing in "++ + atom_to_list(Mod)), + throw({error,Reason}) + end; +save_seqs(Mod,[TC|TCs],Seqs,All) -> + [TC|save_seqs(Mod,TCs,Seqs,All)]; +save_seqs(_,[],_,_) -> + []. + +save_seq(Mod,Seq,SeqTCs) -> + save_seq(Mod,Seq,SeqTCs,apply(Mod,all,[])). + +save_seq(Mod,Seq,SeqTCs,All) -> + check_private(Seq,SeqTCs,All), + check_multiple(Mod,Seq,SeqTCs), + ct_util:save_suite_data({seq,Mod,Seq},SeqTCs), + lists:foreach(fun(TC) -> + ct_util:save_suite_data({seq,Mod,TC},Seq) + end, SeqTCs). + +check_private(Seq,TCs,All) -> + Bad = lists:filter(fun(TC) -> lists:member(TC,All) end, TCs), + if Bad /= [] -> + Reason = io_lib:format("regular test cases not allowed in sequence ~p: " + "~p",[Seq,Bad]), + throw({error,list_to_atom(lists:flatten(Reason))}); + true -> + ok + end. + +check_multiple(Mod,Seq,TCs) -> + Bad = lists:filter(fun(TC) -> + case ct_util:read_suite_data({seq,Mod,TC}) of + Seq1 when Seq1 /= undefined, Seq1 /= Seq -> + true; + + _ -> false + end + end,TCs), + if Bad /= [] -> + Reason = io_lib:format("test cases found in multiple sequences: " + "~p",[Bad]), + throw({error,list_to_atom(lists:flatten(Reason))}); + true -> + ok + end. + +%%! <--- END OF DEPRECATED SUPPORT FOR SEQUENCES +%%!============================================================ + +%% let test_server call this function as a testcase only so that +%% the user may see info about what's missing in the suite +error_in_suite(Config) -> + Reason = test_server:lookup_config(error,Config), + exit(Reason). + +%%%----------------------------------------------------------------- +%%% @spec report(What,Data) -> ok +report(What,Data) -> + case What of + tests_start -> + case ct_util:get_testdata(cover) of + undefined -> + ok; + {_CovFile,_CovNodes,CovImport,CovExport,_CovAppData} -> + %% Always import cover data from files specified by CovImport + %% if no CovExport defined. If CovExport is defined, only + %% import from CovImport files initially, then use CovExport + %% to pass coverdata between proceeding tests (in the same run). + Imps = + case CovExport of + [] -> % don't export data between tests + CovImport; + _ -> + case filelib:is_file(CovExport) of + true -> + [CovExport]; + false -> + CovImport + end + end, + lists:foreach( + fun(Imp) -> + case cover:import(Imp) of + ok -> + ok; + {error,Reason} -> + ct_logs:log("COVER INFO", + "Importing cover data from: ~s fails! " + "Reason: ~p", [Imp,Reason]) + end + end, Imps) + end; + tests_done -> + ok; + tc_start -> + ok; + tc_done -> + {_Suite,Case,Result} = Data, + case {Case,Result} of + {init_per_suite,_} -> + ok; + {end_per_suite,_} -> + ok; + {init_per_group,_} -> + ok; + {end_per_group,_} -> + ok; + {_,ok} -> + add_to_stats(ok); + {_,{skipped,{failed,{_,init_per_testcase,_}}}} -> + add_to_stats(auto_skipped); + {_,{skipped,{require_failed,_}}} -> + add_to_stats(auto_skipped); + {_,{skipped,_}} -> + add_to_stats(user_skipped); + {_,{FailOrSkip,_Reason}} -> + add_to_stats(FailOrSkip) + end; + tc_user_skip -> + %% test case specified as skipped in testspec + %% Data = {Suite,Case,Comment} + ct_event:sync_notify(#event{name=tc_user_skip, + node=node(), + data=Data}), + add_to_stats(user_skipped); + tc_auto_skip -> + %% test case skipped because of error in init_per_suite + %% Data = {Suite,Case,Comment} + + {_Suite,Case,_Result} = Data, + + %% this test case does not have a log, so printouts + %% from event handlers should end up in the main log + ct_event:sync_notify(#event{name=tc_auto_skip, + node=node(), + data=Data}), + if Case /= end_per_suite, Case /= end_per_group -> + add_to_stats(auto_skipped); + true -> + ok + end; + _ -> + ok + end, + catch vts:report(What,Data). + +add_to_stats(Result) -> + Update = fun({Ok,Failed,Skipped={UserSkipped,AutoSkipped}}) -> + Stats = + case Result of + ok -> + {Ok+1,Failed,Skipped}; + failed -> + {Ok,Failed+1,Skipped}; + skipped -> + {Ok,Failed,{UserSkipped+1,AutoSkipped}}; + user_skipped -> + {Ok,Failed,{UserSkipped+1,AutoSkipped}}; + auto_skipped -> + {Ok,Failed,{UserSkipped,AutoSkipped+1}} + end, + ct_event:sync_notify(#event{name=test_stats, + node=node(), + data=Stats}), + Stats + end, + ct_util:update_testdata(stats, Update). + +%%%----------------------------------------------------------------- +%%% @spec warn(What) -> true | false +warn(What) when What==nodes; What==processes -> + false; +warn(_What) -> + true. + +%%%----------------------------------------------------------------- +%%% @spec add_data_dir(File0) -> File1 +add_data_dir(File,Config) when is_atom(File) -> + add_data_dir(atom_to_list(File),Config); + +add_data_dir(File,Config) when is_list(File) -> + case filename:split(File) of + [File] -> + %% no user path, add data dir + case lists:keysearch(data_dir,1,Config) of + {value,{data_dir,DataDir}} -> + filename:join(DataDir,File); + _ -> + File + end; + _ -> + File + end. + + diff --git a/lib/common_test/src/ct_ftp.erl b/lib/common_test/src/ct_ftp.erl new file mode 100644 index 0000000000..5db73066a3 --- /dev/null +++ b/lib/common_test/src/ct_ftp.erl @@ -0,0 +1,380 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc FTP client module (based on the FTP support of the INETS application). +%%% +%%% @type connection() = handle() | ct:target_name() +%%% @type handle() = ct_gen_conn:handle(). Handle for a specific +%%% ftp connection. + +-module(ct_ftp). + +%% API +-export([get/3,put/3, open/1,close/1, send/2,send/3, + recv/2,recv/3, cd/2, ls/2, type/2, delete/2]). + +%% Callbacks +-export([init/3,handle_msg/2,reconnect/2,terminate/2]). + +-include("ct_util.hrl"). + +-record(state,{ftp_pid,target_name}). + +-define(DEFAULT_PORT,21). + +%%%================================================================= +%%% API + +%%%----------------------------------------------------------------- +%%% @spec put(KeyOrName,LocalFile,RemoteFile) -> ok | {error,Reason} +%%% KeyOrName = Key | Name +%%% Key = atom() +%%% Name = ct:target_name() +%%% LocalFile = string() +%%% RemoteFile = string() +%%% +%%% @doc Open a ftp connection and send a file to the remote host. +%%% +%%% <p><code>LocalFile</code> and <code>RemoteFile</code> must be +%%% absolute paths.</p> +%%% +%%% <p>If the target host is a "special" node, the ftp address must be +%%% specified in the config file like this:</p> +%%% <pre> +%%% {node,[{ftp,IpAddr}]}.</pre> +%%% +%%% <p>If the target host is something else, e.g. a unix host, the +%%% config file must also include the username and password (both +%%% strings):</p> +%%% <pre> +%%% {unix,[{ftp,IpAddr}, +%%% {username,Username}, +%%% {password,Password}]}.</pre> +put(KeyOrName,LocalFile,RemoteFile) -> + Fun = fun(Ftp) -> send(Ftp,LocalFile,RemoteFile) end, + open_and_do(KeyOrName,Fun). + +%%%----------------------------------------------------------------- +%%% @spec get(KeyOrName,RemoteFile,LocalFile) -> ok | {error,Reason} +%%% KeyOrName = Key | Name +%%% Key = atom() +%%% Name = ct:target_name() +%%% RemoteFile = string() +%%% LocalFile = string() +%%% +%%% @doc Open a ftp connection and fetch a file from the remote host. +%%% +%%% <p><code>RemoteFile</code> and <code>LocalFile</code> must be +%%% absolute paths.</p> +%%% +%%% <p>The config file must be as for put/3.</p> +%%% @see put/3 +get(KeyOrName,RemoteFile,LocalFile) -> + Fun = fun(Ftp) -> recv(Ftp,RemoteFile,LocalFile) end, + open_and_do(KeyOrName,Fun). + + +%%%----------------------------------------------------------------- +%%% @spec open(KeyOrName) -> {ok,Handle} | {error,Reason} +%%% KeyOrName = Key | Name +%%% Key = atom() +%%% Name = ct:target_name() +%%% Handle = handle() +%%% +%%% @doc Open an FTP connection to the specified node. +%%% <p>You can open one connection for a particular <code>Name</code> and +%%% use the same name as reference for all subsequent operations. If you +%%% want the connection to be associated with <code>Handle</code> instead +%%% (in case you need to open multiple connections to a host for example), +%%% simply use <code>Key</code>, the configuration variable name, to +%%% specify the target. Note that a connection that has no associated target +%%% name can only be closed with the handle value.</p> +open(KeyOrName) -> + case ct_util:get_key_from_name(KeyOrName) of + {ok,node} -> + open(KeyOrName,"erlang","x"); + _ -> + case ct:get_config(KeyOrName) of + undefined -> + log(heading(open,KeyOrName),"Failed: ~p\n", + [{not_available,KeyOrName}]), + {error,{not_available,KeyOrName}}; + _ -> + case ct:get_config({KeyOrName,username}) of + undefined -> + log(heading(open,KeyOrName),"Failed: ~p\n", + [{not_available,{KeyOrName,username}}]), + {error,{not_available,{KeyOrName,username}}}; + Username -> + case ct:get_config({KeyOrName,password}) of + undefined -> + log(heading(open,KeyOrName),"Failed: ~p\n", + [{not_available,{KeyOrName,password}}]), + {error,{not_available,{KeyOrName,password}}}; + Password -> + open(KeyOrName,Username,Password) + end + end + end + end. + +open(KeyOrName,Username,Password) -> + log(heading(open,KeyOrName),"",[]), + case ct:get_config({KeyOrName,ftp}) of + undefined -> + log(heading(open,KeyOrName),"Failed: ~p\n", + [{not_available,{KeyOrName,ftp}}]), + {error,{not_available,{KeyOrName,ftp}}}; + Addr -> + ct_gen_conn:start(KeyOrName,full_addr(Addr),{Username,Password},?MODULE) + end. + + +%%%----------------------------------------------------------------- +%%% @spec send(Connection,LocalFile) -> ok | {error,Reason} +%%% +%%% @doc Send a file over FTP. +%%% <p>The file will get the same name on the remote host.</p> +%%% @see send/3 +send(Connection,LocalFile) -> + send(Connection,LocalFile,filename:basename(LocalFile)). + +%%%----------------------------------------------------------------- +%%% @spec send(Connection,LocalFile,RemoteFile) -> ok | {error,Reason} +%%% Connection = connection() +%%% LocalFile = string() +%%% RemoteFile = string() +%%% +%%% @doc Send a file over FTP. +%%% +%%% <p>The file will be named <code>RemoteFile</code> on the remote host.</p> +send(Connection,LocalFile,RemoteFile) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{send,LocalFile,RemoteFile}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec recv(Connection,RemoteFile) -> ok | {error,Reason} +%%% +%%% @doc Fetch a file over FTP. +%%% <p>The file will get the same name on the local host.</p> +%%% @see recv/3 +recv(Connection,RemoteFile) -> + recv(Connection,RemoteFile,filename:basename(RemoteFile)). + +%%%----------------------------------------------------------------- +%%% @spec recv(Connection,RemoteFile,LocalFile) -> ok | {error,Reason} +%%% Connection = connection() +%%% RemoteFile = string() +%%% LocalFile = string() +%%% +%%% @doc Fetch a file over FTP. +%%% +%%% <p>The file will be named <code>LocalFile</code> on the local host.</p> +recv(Connection,RemoteFile,LocalFile) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{recv,RemoteFile,LocalFile}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec cd(Connection,Dir) -> ok | {error,Reason} +%%% Connection = connection() +%%% Dir = string() +%%% +%%% @doc Change directory on remote host. +cd(Connection,Dir) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{cd,Dir}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec ls(Connection,Dir) -> {ok,Listing} | {error,Reason} +%%% Connection = connection() +%%% Dir = string() +%%% Listing = string() +%%% +%%% @doc List the directory Dir. +ls(Connection,Dir) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{ls,Dir}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec type(Connection,Type) -> ok | {error,Reason} +%%% Connection = connection() +%%% Type = ascii | binary +%%% +%%% @doc Change file transfer type +type(Connection,Type) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{type,Type}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec delete(Connection,File) -> ok | {error,Reason} +%%% Connection = connection() +%%% File = string() +%%% +%%% @doc Delete a file on remote host +delete(Connection,File) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{delete,File}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec close(Connection) -> ok | {error,Reason} +%%% Connection = connection() +%%% +%%% @doc Close the FTP connection. +close(Connection) -> + case get_handle(Connection) of + {ok,Pid} -> + ct_gen_conn:stop(Pid); + Error -> + Error + end. + + +%%%================================================================= +%%% Callback functions + +%% @hidden +init(KeyOrName,{IP,Port},{Username,Password}) -> + case ftp_connect(IP,Port,Username,Password) of + {ok,FtpPid} -> + log(heading(init,KeyOrName), + "Opened ftp connection:\nIP: ~p\nUsername: ~p\nPassword: ~p\n", + [IP,Username,lists:duplicate(length(Password),$*)]), + {ok,FtpPid,#state{ftp_pid=FtpPid,target_name=KeyOrName}}; + Error -> + Error + end. + +ftp_connect(IP,Port,Username,Password) -> + inets:start(), + case inets:start(ftpc,[{host,IP},{port,Port}]) of + {ok,FtpPid} -> + case ftp:user(FtpPid,Username,Password) of + ok -> + {ok,FtpPid}; + {error,Reason} -> + {error,{user,Reason}} + end; + {error,Reason} -> + {error,{open,Reason}} + end. + +%% @hidden +handle_msg({send,LocalFile,RemoteFile},State) -> + log(heading(send,State#state.target_name), + "LocalFile: ~p\nRemoteFile: ~p\n",[LocalFile,RemoteFile]), + Result = ftp:send(State#state.ftp_pid,LocalFile,RemoteFile), + {Result,State}; +handle_msg({recv,RemoteFile,LocalFile},State) -> + log(heading(recv,State#state.target_name), + "RemoteFile: ~p\nLocalFile: ~p\n",[RemoteFile,LocalFile]), + Result = ftp:recv(State#state.ftp_pid,RemoteFile,LocalFile), + {Result,State}; +handle_msg({cd,Dir},State) -> + log(heading(cd,State#state.target_name),"Dir: ~p\n",[Dir]), + Result = ftp:cd(State#state.ftp_pid,Dir), + {Result,State}; +handle_msg({ls,Dir},State) -> + log(heading(ls,State#state.target_name),"Dir: ~p\n",[Dir]), + Result = ftp:ls(State#state.ftp_pid,Dir), + {Result,State}; +handle_msg({type,Type},State) -> + log(heading(type,State#state.target_name),"Type: ~p\n",[Type]), + Result = ftp:type(State#state.ftp_pid,Type), + {Result,State}; +handle_msg({delete,File},State) -> + log(heading(delete,State#state.target_name),"Delete file: ~p\n",[File]), + Result = ftp:delete(State#state.ftp_pid,File), + {Result,State}. + +%% @hidden +reconnect(_Addr,_State) -> + {error,no_reconnection_of_ftp}. + +%% @hidden +terminate(FtpPid,State) -> + log(heading(terminate,State#state.target_name), + "Closing FTP connection.\nHandle: ~p\n",[FtpPid]), + inets:stop(ftpc,FtpPid). + + +%%%================================================================= +%%% Internal function +get_handle(Pid) when is_pid(Pid) -> + {ok,Pid}; +get_handle(Name) -> + case ct_util:get_connections(Name,?MODULE) of + {ok,[{Pid,_}|_]} -> + {ok,Pid}; + {ok,[]} -> + open(Name); + Error -> + Error + end. + +full_addr({Ip,Port}) -> + {Ip,Port}; +full_addr(Ip) -> + {Ip,?DEFAULT_PORT}. + +call(Pid,Msg) -> + ct_gen_conn:call(Pid,Msg). + + +heading(Function,Name) -> + io_lib:format("ct_ftp:~w ~p",[Function,Name]). + +log(Heading,Str,Args) -> + ct_gen_conn:log(Heading,Str,Args). + + +open_and_do(Name,Fun) -> + case open(Name) of + {ok,Ftp} -> + R = Fun(Ftp), + close(Ftp), + R; + Error -> + Error + end. + + diff --git a/lib/common_test/src/ct_gen_conn.erl b/lib/common_test/src/ct_gen_conn.erl new file mode 100644 index 0000000000..a31e57c7ea --- /dev/null +++ b/lib/common_test/src/ct_gen_conn.erl @@ -0,0 +1,286 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Generic connection owner process. +%%% +%%% @type handle() = pid(). A handle for using a connection implemented +%%% with ct_gen_conn.erl. + +-module(ct_gen_conn). + +-compile(export_all). + +-export([start/4, stop/1]). +-export([call/2, do_within_time/2]). + +-ifdef(debug). +-define(dbg,true). +-else. +-define(dbg,false). +-endif. + +-record(gen_opts,{callback, + name, + address, + init_data, + conn_pid, + cb_state, + ct_util_server}). + +%%%----------------------------------------------------------------- +%%% @spec start(Name,Address,InitData,CallbackMod) -> +%%% {ok,Handle} | {error,Reason} +%%% Name = term() +%%% CallbackMod = atom() +%%% InitData = term() +%%% Address = term() +%%% +%%% @doc Open a connection and start the generic connection owner process. +%%% +%%% <p>The <code>CallbackMod</code> is a specific callback module for +%%% each type of connection (e.g. telnet, ftp,...). It must export the +%%% function <code>init/3</code> which takes the arguments +%%% <code>Name</code>, <code>Addresse</code>) and +%%% <code>InitData</code> and returna +%%% <code>{ok,ConnectionPid,State}</code> or +%%% <code>{error,Reason}</code>.</p> +start(Name,Address,InitData,CallbackMod) -> + case ct_util:does_connection_exist(Name,Address,CallbackMod) of + {ok,Pid} -> + log("ct_gen_conn:start","Using existing connection!\n",[]), + {ok,Pid}; + false -> + Self = self(), + Pid = spawn(fun() -> + init_gen(Self, #gen_opts{callback=CallbackMod, + name=Name, + address=Address, + init_data=InitData}) + end), + MRef = erlang:monitor(process,Pid), + receive + {connected,Pid} -> + erlang:demonitor(MRef), + ct_util:register_connection(Name,Address,CallbackMod,Pid), + {ok,Pid}; + {Error,Pid} -> + receive {'DOWN',MRef,process,_,_} -> ok end, + Error; + {'DOWN',MRef,process,_,Reason} -> + log("ct_gen_conn:start", + "Connection process died: ~p\n", + [Reason]), + {error,{connection_process_died,Reason}} + end + end. + + +%%%----------------------------------------------------------------- +%%% @spec stop(Handle) -> ok +%%% Handle = handle() +%%% +%%% @doc Close the telnet connection and stop the process managing it. +stop(Pid) -> + call(Pid,stop). + +%%%----------------------------------------------------------------- +%%% @spec log(Heading,Format,Args) -> ok +%%% +%%% @doc Log activities on the current connection (tool-internal use only). +%%% @see ct_logs:log/3 +log(Heading,Format,Args) -> + log(log,[Heading,Format,Args]). + +%%%----------------------------------------------------------------- +%%% @spec start_log(Heading) -> ok +%%% +%%% @doc Log activities on the current connection (tool-internal use only). +%%% @see ct_logs:start_log/1 +start_log(Heading) -> + log(start_log,[Heading]). + +%%%----------------------------------------------------------------- +%%% @spec cont_log(Format,Args) -> ok +%%% +%%% @doc Log activities on the current connection (tool-internal use only). +%%% @see ct_logs:cont_log/2 +cont_log(Format,Args) -> + log(cont_log,[Format,Args]). + +%%%----------------------------------------------------------------- +%%% @spec end_log() -> ok +%%% +%%% @doc Log activities on the current connection (tool-internal use only). +%%% @see ct_logs:end_log/0 +end_log() -> + log(end_log,[]). + +%%%----------------------------------------------------------------- +%%% @spec do_within_time(Fun,Timeout) -> FunResult | {error,Reason} +%%% Fun = function() +%%% Timeout = integer() +%%% +%%% @doc Execute a function within a limited time (tool-internal use only). +%%% +%%% <p>Execute the given <code>Fun</code>, but interrupt if it takes +%%% more than <code>Timeout</code> milliseconds.</p> +%%% +%%% <p>The execution is also interrupted if the connection is +%%% closed.</p> +do_within_time(Fun,Timeout) -> + Self = self(), + Silent = get(silent), + TmpPid = spawn_link(fun() -> put(silent,Silent), + R = Fun(), + Self ! {self(),R} + end), + ConnPid = get(conn_pid), + receive + {TmpPid,Result} -> + Result; + {'EXIT',ConnPid,_Reason}=M -> + unlink(TmpPid), + exit(TmpPid,kill), + self() ! M, + {error,connection_closed} + after + Timeout -> + exit(TmpPid,kill), + receive + {TmpPid,Result} -> + %% TmpPid just managed to send the result at the same time + %% as the timeout expired. + receive {'EXIT',TmpPid,_reason} -> ok end, + Result; + {'EXIT',TmpPid,killed} -> + %% TmpPid did not send the result before the timeout expired. + {error,timeout} + end + end. + +%%%================================================================= +%%% Internal functions +call(Pid,Msg) -> + MRef = erlang:monitor(process,Pid), + Ref = make_ref(), + Pid ! {Msg,{self(),Ref}}, + receive + {Ref, Result} -> + erlang:demonitor(MRef), + case Result of + {retry,_Data} -> + call(Pid,Result); + Other -> + Other + end; + {'DOWN',MRef,process,_,Reason} -> + {error,{process_down,Pid,Reason}} + end. + +return({To,Ref},Result) -> + To ! {Ref, Result}. + +init_gen(Parent,Opts) -> + process_flag(trap_exit,true), + CtUtilServer = whereis(ct_util_server), + link(CtUtilServer), + put(silent,false), + case catch (Opts#gen_opts.callback):init(Opts#gen_opts.name, + Opts#gen_opts.address, + Opts#gen_opts.init_data) of + {ok,ConnPid,State} when is_pid(ConnPid) -> + link(ConnPid), + put(conn_pid,ConnPid), + Parent ! {connected,self()}, + loop(Opts#gen_opts{conn_pid=ConnPid, + cb_state=State, + ct_util_server=CtUtilServer}); + {error,Reason} -> + Parent ! {{error,Reason},self()} + end. + +loop(Opts) -> + receive + {'EXIT',Pid,Reason} when Pid==Opts#gen_opts.conn_pid -> + log("Connection down!\nOpening new!","Reason: ~p\nAddress: ~p\n", + [Reason,Opts#gen_opts.address]), + case reconnect(Opts) of + {ok, NewPid, NewState} -> + link(NewPid), + put(conn_pid,NewPid), + loop(Opts#gen_opts{conn_pid=NewPid,cb_state=NewState}); + Error -> + ct_util:unregister_connection(self()), + log("Reconnect failed. Giving up!","Reason: ~p\n",[Error]) + end; + {'EXIT',Pid,Reason} -> + case Opts#gen_opts.ct_util_server of + Pid -> + exit(Reason); + _ -> + loop(Opts) + end; + {stop, From} -> + ct_util:unregister_connection(self()), + (Opts#gen_opts.callback):terminate(Opts#gen_opts.conn_pid, + Opts#gen_opts.cb_state), + return(From,ok), + ok; + {{retry,{Error,_Name,CPid,_Msg}}, From} when CPid == Opts#gen_opts.conn_pid -> + %% only retry if failure is because of a reconnection + Return = case Error of + {error,_} -> Error; + Reason -> {error,Reason} + end, + return(From, Return), + loop(Opts); + {{retry,{_Error,_Name,_CPid,Msg}}, From} -> + log("Rerunning command","Connection reestablished. Rerunning command...",[]), + {Return,NewState} = + (Opts#gen_opts.callback):handle_msg(Msg,Opts#gen_opts.cb_state), + return(From, Return), + loop(Opts#gen_opts{cb_state=NewState}); + {Msg,From={Pid,_Ref}} when is_pid(Pid) -> + {Return,NewState} = + (Opts#gen_opts.callback):handle_msg(Msg,Opts#gen_opts.cb_state), + return(From, Return), + loop(Opts#gen_opts{cb_state=NewState}) + end. + +nozero({ok,S}) when is_list(S) -> + {ok,[C || C <- S, + C=/=0, + C=/=13]}; +nozero(M) -> + M. + +reconnect(Opts) -> + (Opts#gen_opts.callback):reconnect(Opts#gen_opts.address, + Opts#gen_opts.cb_state). + + +log(Func,Args) -> + case get(silent) of + true when not ?dbg-> + ok; + _ -> + apply(ct_logs,Func,Args) + end. + + diff --git a/lib/common_test/src/ct_line.erl b/lib/common_test/src/ct_line.erl new file mode 100644 index 0000000000..4af9da5463 --- /dev/null +++ b/lib/common_test/src/ct_line.erl @@ -0,0 +1,266 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Parse transform for inserting line numbers + +-module(ct_line). + +-record(vars, {module, % atom() Module name + vsn, % atom() + + init_info=[], % [{M,F,A,C,L}] + + function, % atom() + arity, % int() + clause, % int() + lines, % [int()] + depth, % int() + is_guard=false % boolean + }). + +-export([parse_transform/2, + line/1]). + +line(LOC={{Mod,Func},_Line}) -> + Lines = case get(test_server_loc) of + [{{Mod,Func},_}|Ls] -> + Ls; + Ls when is_list(Ls) -> + case length(Ls) of + 10 -> + [_|T]=lists:reverse(Ls), + lists:reverse(T); + _ -> + Ls + end; + _ -> + [] + end, + put(test_server_loc,[LOC|Lines]). + +parse_transform(Forms, _Options) -> + transform(Forms, _Options). + +%% forms(Fs) -> lists:map(fun (F) -> form(F) end, Fs). + +transform(Forms, _Options)-> + Vars0 = #vars{}, + {ok, MungedForms, _Vars} = transform(Forms, [], Vars0), + MungedForms. + + +transform([Form|Forms], MungedForms, Vars) -> + case munge(Form, Vars) of + ignore -> + transform(Forms, MungedForms, Vars); + {MungedForm, Vars2} -> + transform(Forms, [MungedForm|MungedForms], Vars2) + end; +transform([], MungedForms, Vars) -> + {ok, lists:reverse(MungedForms), Vars}. + +%% This code traverses the abstract code, stored as the abstract_code +%% chunk in the BEAM file, as described in absform(3) for Erlang/OTP R8B +%% (Vsn=abstract_v2). +%% The abstract format after preprocessing differs slightly from the abstract +%% format given eg using epp:parse_form, this has been noted in comments. +munge(Form={attribute,_,module,Module}, Vars) -> + Vars2 = Vars#vars{module=Module}, + {Form, Vars2}; + +munge({function,0,module_info,_Arity,_Clauses}, _Vars) -> + ignore; % module_info will be added again when the forms are recompiled +munge({function,Line,Function,Arity,Clauses}, Vars) -> + Vars2 = Vars#vars{function=Function, + arity=Arity, + clause=1, + lines=[], + depth=1}, + {MungedClauses, Vars3} = munge_clauses(Clauses, Vars2, []), + {{function,Line,Function,Arity,MungedClauses}, Vars3}; +munge(Form, Vars) -> % attributes + {Form, Vars}. + +munge_clauses([{clause,Line,Pattern,Guards,Body}|Clauses], Vars, MClauses) -> + {MungedGuards, _Vars} = munge_exprs(Guards, Vars#vars{is_guard=true},[]), + + case Vars#vars.depth of + 1 -> % function clause + {MungedBody, Vars2} = munge_body(Body, Vars#vars{depth=2}, []), + ClauseInfo = {Vars2#vars.module, + Vars2#vars.function, + Vars2#vars.arity, + Vars2#vars.clause, + length(Vars2#vars.lines)}, + InitInfo = [ClauseInfo | Vars2#vars.init_info], + Vars3 = Vars2#vars{init_info=InitInfo, + clause=(Vars2#vars.clause)+1, + lines=[], + depth=1}, + munge_clauses(Clauses, Vars3, + [{clause,Line,Pattern,MungedGuards,MungedBody}| + MClauses]); + + 2 -> % receive-, case- or if clause + {MungedBody, Vars2} = munge_body(Body, Vars, []), + munge_clauses(Clauses, Vars2, + [{clause,Line,Pattern,MungedGuards,MungedBody}| + MClauses]) + end; +munge_clauses([], Vars, MungedClauses) -> + {lists:reverse(MungedClauses), Vars}. + +munge_body([Expr|Body], Vars, MungedBody) -> + %% Here is the place to add a call to cover:bump/6! + Line = element(2, Expr), + Lines = Vars#vars.lines, + case lists:member(Line,Lines) of + true -> % already a bump at this line! + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + munge_body(Body, Vars2, [MungedExpr|MungedBody]); + false -> + Bump = {call, 0, {remote,0,{atom,0,?MODULE},{atom,0,line}}, + [{tuple,0,[{tuple,0,[{atom,0,Vars#vars.module}, + {atom, 0, Vars#vars.function}]}, + {integer, 0, Line}]}]}, + Lines2 = [Line|Lines], + + {MungedExpr, Vars2} = munge_expr(Expr, Vars#vars{lines=Lines2}), + munge_body(Body, Vars2, [MungedExpr,Bump|MungedBody]) + end; +munge_body([], Vars, MungedBody) -> + {lists:reverse(MungedBody), Vars}. + +munge_expr({match,Line,ExprL,ExprR}, Vars) -> + {MungedExprL, Vars2} = munge_expr(ExprL, Vars), + {MungedExprR, Vars3} = munge_expr(ExprR, Vars2), + {{match,Line,MungedExprL,MungedExprR}, Vars3}; +munge_expr({tuple,Line,Exprs}, Vars) -> + {MungedExprs, Vars2} = munge_exprs(Exprs, Vars, []), + {{tuple,Line,MungedExprs}, Vars2}; +munge_expr({record,Line,Expr,Exprs}, Vars) -> + %% Only for Vsn=raw_abstract_v1 + {MungedExprName, Vars2} = munge_expr(Expr, Vars), + {MungedExprFields, Vars3} = munge_exprs(Exprs, Vars2, []), + {{record,Line,MungedExprName,MungedExprFields}, Vars3}; +munge_expr({record_field,Line,ExprL,ExprR}, Vars) -> + %% Only for Vsn=raw_abstract_v1 + {MungedExprL, Vars2} = munge_expr(ExprL, Vars), + {MungedExprR, Vars3} = munge_expr(ExprR, Vars2), + {{record_field,Line,MungedExprL,MungedExprR}, Vars3}; +munge_expr({cons,Line,ExprH,ExprT}, Vars) -> + {MungedExprH, Vars2} = munge_expr(ExprH, Vars), + {MungedExprT, Vars3} = munge_expr(ExprT, Vars2), + {{cons,Line,MungedExprH,MungedExprT}, Vars3}; +munge_expr({op,Line,Op,ExprL,ExprR}, Vars) -> + {MungedExprL, Vars2} = munge_expr(ExprL, Vars), + {MungedExprR, Vars3} = munge_expr(ExprR, Vars2), + {{op,Line,Op,MungedExprL,MungedExprR}, Vars3}; +munge_expr({op,Line,Op,Expr}, Vars) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + {{op,Line,Op,MungedExpr}, Vars2}; +munge_expr({'catch',Line,Expr}, Vars) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + {{'catch',Line,MungedExpr}, Vars2}; +munge_expr({call,Line1,{remote,Line2,ExprM,ExprF},Exprs}, + Vars) when Vars#vars.is_guard==false-> + {MungedExprM, Vars2} = munge_expr(ExprM, Vars), + {MungedExprF, Vars3} = munge_expr(ExprF, Vars2), + {MungedExprs, Vars4} = munge_exprs(Exprs, Vars3, []), + {{call,Line1,{remote,Line2,MungedExprM,MungedExprF},MungedExprs}, Vars4}; +munge_expr({call,Line1,{remote,_Line2,_ExprM,ExprF},Exprs}, + Vars) when Vars#vars.is_guard==true -> + %% Difference in abstract format after preprocessing: BIF calls in guards + %% are translated to {remote,...} (which is not allowed as source form) + %% NOT NECESSARY FOR Vsn=raw_abstract_v1 + munge_expr({call,Line1,ExprF,Exprs}, Vars); +munge_expr({call,Line,Expr,Exprs}, Vars) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + {MungedExprs, Vars3} = munge_exprs(Exprs, Vars2, []), + {{call,Line,MungedExpr,MungedExprs}, Vars3}; +munge_expr({lc,Line,Expr,LC}, Vars) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + {MungedLC, Vars3} = munge_lc(LC, Vars2, []), + {{lc,Line,MungedExpr,MungedLC}, Vars3}; +munge_expr({block,Line,Body}, Vars) -> + {MungedBody, Vars2} = munge_body(Body, Vars, []), + {{block,Line,MungedBody}, Vars2}; +munge_expr({'if',Line,Clauses}, Vars) -> + {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []), + {{'if',Line,MungedClauses}, Vars2}; +munge_expr({'case',Line,Expr,Clauses}, Vars) -> + {MungedExpr,Vars2} = munge_expr(Expr,Vars), + {MungedClauses,Vars3} = munge_clauses(Clauses, Vars2, []), + {{'case',Line,MungedExpr,MungedClauses}, Vars3}; +munge_expr({'receive',Line,Clauses}, Vars) -> + {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []), + {{'receive',Line,MungedClauses}, Vars2}; +munge_expr({'receive',Line,Clauses,Expr,Body}, Vars) -> + {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []), + {MungedExpr, Vars3} = munge_expr(Expr, Vars2), + {MungedBody, Vars4} = munge_body(Body, Vars3, []), + {{'receive',Line,MungedClauses,MungedExpr,MungedBody}, Vars4}; +munge_expr({'try',Line,Exprs,Clauses,CatchClauses}, Vars) -> + {MungedExprs, Vars1} = munge_exprs(Exprs, Vars, []), + {MungedClauses, Vars2} = munge_clauses(Clauses, Vars1, []), + {MungedCatchClauses, Vars3} = munge_clauses(CatchClauses, Vars2, []), + {{'try',Line,MungedExprs,MungedClauses,MungedCatchClauses}, Vars3}; +%% Difference in abstract format after preprocessing: Funs get an extra +%% element Extra. +%% NOT NECESSARY FOR Vsn=raw_abstract_v1 +munge_expr({'fun',Line,{function,Name,Arity},_Extra}, Vars) -> + {{'fun',Line,{function,Name,Arity}}, Vars}; +munge_expr({'fun',Line,{clauses,Clauses},_Extra}, Vars) -> + {MungedClauses,Vars2}=munge_clauses(Clauses, Vars, []), + {{'fun',Line,{clauses,MungedClauses}}, Vars2}; +munge_expr({'fun',Line,{clauses,Clauses}}, Vars) -> + %% Only for Vsn=raw_abstract_v1 + {MungedClauses,Vars2}=munge_clauses(Clauses, Vars, []), + {{'fun',Line,{clauses,MungedClauses}}, Vars2}; +munge_expr(Form, Vars) -> % var|char|integer|float|string|atom|nil|bin|eof + {Form, Vars}. + +munge_exprs([Expr|Exprs], Vars, MungedExprs) when Vars#vars.is_guard==true, + is_list(Expr) -> + {MungedExpr, _Vars} = munge_exprs(Expr, Vars, []), + munge_exprs(Exprs, Vars, [MungedExpr|MungedExprs]); +munge_exprs([Expr|Exprs], Vars, MungedExprs) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + munge_exprs(Exprs, Vars2, [MungedExpr|MungedExprs]); +munge_exprs([], Vars, MungedExprs) -> + {lists:reverse(MungedExprs), Vars}. + +munge_lc([{generate,Line,Pattern,Expr}|LC], Vars, MungedLC) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + munge_lc(LC, Vars2, [{generate,Line,Pattern,MungedExpr}|MungedLC]); +munge_lc([Expr|LC], Vars, MungedLC) -> + {MungedExpr, Vars2} = munge_expr(Expr, Vars), + munge_lc(LC, Vars2, [MungedExpr|MungedLC]); +munge_lc([], Vars, MungedLC) -> + {lists:reverse(MungedLC), Vars}. + + + + + + + + + + diff --git a/lib/common_test/src/ct_logs.erl b/lib/common_test/src/ct_logs.erl new file mode 100644 index 0000000000..bd1a89ae1f --- /dev/null +++ b/lib/common_test/src/ct_logs.erl @@ -0,0 +1,1606 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Logging functionality for Common Test Framework. +%%% +%%% <p>This module implements +%%% <ul> +%%% <li>Internal logging of activities in Common Test Framework</li> +%%% <li>Compilation of test results into index pages on several levels</li> +%%% </ul> +%%% </p> + +-module(ct_logs). + +-export([init/1,close/1,init_tc/0,end_tc/1]). +-export([get_log_dir/0,log/3,start_log/1,cont_log/2,end_log/0]). +-export([set_stylesheet/2,clear_stylesheet/1]). +-export([add_external_logs/1,add_link/3]). +-export([make_last_run_index/0]). +-export([make_all_suites_index/1,make_all_runs_index/1]). + +%% Logging stuff directly from testcase +-export([tc_log/3,tc_print/3,tc_pal/3]). + +%% Simulate logger process for use without ct environment running +-export([simulate/0]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). +-include_lib("kernel/include/file.hrl"). + +-define(suitelog_name,"suite.log"). +-define(run_summary, "suite.summary"). +-define(logdir_ext, ".logs"). +-define(ct_log_name, "ctlog.html"). +-define(all_runs_name, "all_runs.html"). +-define(index_name, "index.html"). +-define(totals_name, "totals.info"). + +-define(table_color1,"#ADD8E6"). +-define(table_color2,"#E4F0FE"). +-define(table_color3,"#F0F8FF"). + +-define(testname_width, 70). + +-define(abs(Name), filename:absname(Name)). + +%%%----------------------------------------------------------------- +%%% @spec init(Mode) -> Result +%%% Mode = normal | interactive +%%% Result = {StartTime,LogDir} +%%% StartTime = term() +%%% LogDir = string() +%%% +%%% @doc Initiate the logging mechanism (tool-internal use only). +%%% +%%% <p>This function is called by ct_util.erl when testing is +%%% started. A new directory named ct_run.<timestamp> is created +%%% and all logs are stored under this directory.</p> +%%% +init(Mode) -> + Self = self(), + Pid = spawn_link(fun() -> logger(Self,Mode) end), + MRef = erlang:monitor(process,Pid), + receive + {started,Pid,Result} -> + erlang:demonitor(MRef), + Result; + {'DOWN',MRef,process,_,Reason} -> + exit({could_not_start_process,?MODULE,Reason}) + end. + +make_dirname({{YY,MM,DD},{H,M,S}}) -> + io_lib:format(logdir_node_prefix()++".~w-~2.2.0w-~2.2.0w_~2.2.0w.~2.2.0w.~2.2.0w", + [YY,MM,DD,H,M,S]). + +logdir_prefix() -> + "ct_run". +logdir_node_prefix() -> + logdir_prefix()++"."++atom_to_list(node()). + +%%%----------------------------------------------------------------- +%%% @spec close(How) -> ok +%%% +%%% @doc Create index pages with test results and close the CT Log +%%% (tool-internal use only). +close(How) -> + make_last_run_index(), + + ct_event:notify(#event{name=stop_logging,node=node(),data=[]}), + + case whereis(?MODULE) of + Pid when is_pid(Pid) -> + MRef = erlang:monitor(process,Pid), + ?MODULE ! stop, + receive + {'DOWN',MRef,process,_,_} -> + ok + end; + undefined -> + ok + end, + + if How == clean -> + case cleanup() of + ok -> + ok; + Error -> + io:format("Warning! Cleanup failed: ~p~n", [Error]) + end; + true -> + file:set_cwd("..") + end, + + make_all_suites_index(stop), + make_all_runs_index(stop), + + ok. + +%%%----------------------------------------------------------------- +%%% @spec set_stylesheet(TC,SSFile) -> ok +set_stylesheet(TC, SSFile) -> + cast({set_stylesheet,TC,SSFile}). + +%%%----------------------------------------------------------------- +%%% @spec clear_stylesheet(TC) -> ok +clear_stylesheet(TC) -> + cast({clear_stylesheet,TC}). + +%%%----------------------------------------------------------------- +%%% @spec get_log_dir() -> {ok,Dir} | {error,Reason} +get_log_dir() -> + call(get_log_dir). + +%%%----------------------------------------------------------------- +%%% make_last_run_index() -> ok +make_last_run_index() -> + call(make_last_run_index). + +call(Msg) -> + case whereis(?MODULE) of + undefined -> + {error,does_not_exist}; + Pid -> + MRef = erlang:monitor(process,Pid), + Ref = make_ref(), + ?MODULE ! {Msg,{self(),Ref}}, + receive + {Ref, Result} -> + erlang:demonitor(MRef), + Result; + {'DOWN',MRef,process,_,Reason} -> + {error,{process_down,?MODULE,Reason}} + end + end. + +return({To,Ref},Result) -> + To ! {Ref, Result}. + +cast(Msg) -> + case whereis(?MODULE) of + undefined -> + {error,does_not_exist}; + _Pid -> + ?MODULE ! Msg + end. + + +%%%----------------------------------------------------------------- +%%% @spec init_tc() -> ok +%%% +%%% @doc Test case initiation (tool-internal use only). +%%% +%%% <p>This function is called by ct_framework:init_tc/3</p> +init_tc() -> + call({init_tc,self(),group_leader()}), + ok. + +%%%----------------------------------------------------------------- +%%% @spec end_tc(TCPid) -> ok | {error,Reason} +%%% +%%% @doc Test case clean up (tool-internal use only). +%%% +%%% <p>This function is called by ct_framework:end_tc/3</p> +end_tc(TCPid) -> + %% use call here so that the TC process will wait and receive + %% possible exit signals from ct_logs before end_tc returns ok + call({end_tc,TCPid}). + +%%%----------------------------------------------------------------- +%%% @spec log(Heading,Format,Args) -> ok +%%% +%%% @doc Log internal activity (tool-internal use only). +%%% +%%% <p>This function writes an entry to the currently active log, +%%% i.e. either the CT log or a test case log.</p> +%%% +%%% <p><code>Heading</code> is a short string indicating what type of +%%% activity it is. <code>Format</code> and <code>Args</code> is the +%%% data to log (as in <code>io:format(Format,Args)</code>).</p> +log(Heading,Format,Args) -> + cast({log,self(),group_leader(), + [{int_header(),[log_timestamp(now()),Heading]}, + {Format,Args}, + {int_footer(),[]}]}), + ok. + +%%%----------------------------------------------------------------- +%%% @spec start_log(Heading) -> ok +%%% +%%% @doc Starts the logging of an activity (tool-internal use only). +%%% +%%% <p>This function must be used in combination with +%%% <code>cont_log/2</code> and <code>end_log/0</code>. The intention +%%% is to call <code>start_log</code> once, then <code>cont_log</code> +%%% any number of times and finally <code>end_log</code> once.</p> +%%% +%%% <p>For information about the parameters, see <code>log/3</code>.</p> +%%% +%%% @see log/3 +%%% @see cont_log/2 +%%% @see end_log/0 +start_log(Heading) -> + cast({log,self(),group_leader(), + [{int_header(),[log_timestamp(now()),Heading]}]}), + ok. + +%%%----------------------------------------------------------------- +%%% @spec cont_log(Format,Args) -> ok +%%% +%%% @doc Adds information about an activity (tool-internal use only). +%%% +%%% @see start_log/1 +%%% @see end_log/0 +cont_log([],[]) -> + ok; +cont_log(Format,Args) -> + maybe_log_timestamp(), + cast({log,self(),group_leader(),[{Format,Args}]}), + ok. + +%%%----------------------------------------------------------------- +%%% @spec end_log() -> ok +%%% +%%% @doc Ends the logging of an activity (tool-internal use only). +%%% +%%% @see start_log/1 +%%% @see cont_log/2 +end_log() -> + cast({log,self(),group_leader(),[{int_footer(), []}]}), + ok. + + +%%%----------------------------------------------------------------- +%%% @spec add_external_logs(Logs) -> ok +%%% Logs = [Log] +%%% Log = string() +%%% +%%% @doc Print a link to each given <code>Log</code> in the test case +%%% log. +%%% +%%% <p>The given <code>Logs</code> must exist in the priv dir of the +%%% calling test suite.</p> +add_external_logs(Logs) -> + start_log("External Logs"), + [cont_log("<a href=~p>~s</a>\n", + [filename:join("log_private",Log),Log]) || Log <- Logs], + end_log(). + +%%%----------------------------------------------------------------- +%%% @spec add_link(Heading,File,Type) -> ok +%%% Heading = string() +%%% File = string() +%%% Type = string() +%%% +%%% @doc Print a link to a given file stored in the priv_dir of the +%%% calling test suite. +add_link(Heading,File,Type) -> + log(Heading,"<a href=~p type=~p>~s</a>\n", + [filename:join("log_private",File),Type,File]). + + + +%%%----------------------------------------------------------------- +%%% @spec tc_log(Category,Format,Args) -> ok +%%% Category = atom() +%%% Format = string() +%%% Args = list() +%%% +%%% @doc Printout from a testcase. +%%% +%%% <p>This function is called by <code>ct</code> when logging +%%% stuff directly from a testcase (i.e. not from within the CT +%%% framework).</p> +tc_log(Category,Format,Args) -> + cast({log,self(),group_leader(),[{div_header(Category),[]}, + {Format,Args}, + {div_footer(),[]}]}), + ok. + +%%%----------------------------------------------------------------- +%%% @spec tc_print(Category,Format,Args) -> ok +%%% Category = atom() +%%% Format = string() +%%% Args = list() +%%% +%%% @doc Console printout from a testcase. +%%% +%%% <p>This function is called by <code>ct</code> when printing +%%% stuff a testcase on the user console.</p> +tc_print(Category,Format,Args) -> + print_heading(Category), + io:format(user,Format,Args), + io:format(user,"\n\n",[]), + ok. + +print_heading(default) -> + io:format(user, + "----------------------------------------------------\n~s\n", + [log_timestamp(now())]); +print_heading(Category) -> + io:format(user, + "----------------------------------------------------\n~s ~w\n", + [log_timestamp(now()),Category]). + + +%%%----------------------------------------------------------------- +%%% @spec tc_pal(Category,Format,Args) -> ok +%%% Category = atom() +%%% Format = string() +%%% Args = list() +%%% +%%% @doc Print and log from a testcase. +%%% +%%% <p>This function is called by <code>ct</code> when logging +%%% stuff directly from a testcase. The info is written both in the +%%% log and on the console.</p> +tc_pal(Category,Format,Args) -> + tc_print(Category,Format,Args), + cast({log,self(),group_leader(),[{div_header(Category),[]}, + {Format,Args}, + {div_footer(),[]}]}), + ok. + + +%%%================================================================= +%%% Internal functions +int_header() -> + "<div class=\"ct_internal\"><b>*** CT ~s *** ~s</b>". +int_footer() -> + "</div>". + +div_header(Class) -> + "<div class=\"" ++ atom_to_list(Class) ++ "\"><b>*** User " ++ + log_timestamp(now()) ++ " ***</b>". +div_footer() -> + "</div>". + + +maybe_log_timestamp() -> + {MS,S,US} = now(), + case get(log_timestamp) of + {MS,S,_} -> + ok; + _ -> + cast({log,self(),group_leader(), + [{"<i>~s</i>",[log_timestamp({MS,S,US})]}]}) + end. + +log_timestamp(Now) -> + put(log_timestamp,Now), + {_,{H,M,S}} = calendar:now_to_local_time(Now), + lists:flatten(io_lib:format("~2.2.0w:~2.2.0w:~2.2.0w", + [H,M,S])). + +%%%----------------------------------------------------------------- +%%% The logger server +-record(logger_state,{parent, + log_dir, + start_time, + orig_GL, + ct_log_fd, + tc_groupleaders, + stylesheet}). + +logger(Parent,Mode) -> + register(?MODULE,self()), + + %%! Below is a temporary workaround for the limitation of + %%! max one test run per second. + %%! ---> + Time0 = calendar:local_time(), + Dir0 = make_dirname(Time0), + {Time,Dir} = + case filelib:is_dir(Dir0) of + true -> + timer:sleep(1000), + Time1 = calendar:local_time(), + Dir1 = make_dirname(Time1), + + {Time1,Dir1}; + false -> + {Time0,Dir0} + end, + %%! <--- + + file:make_dir(Dir), + ct_event:notify(#event{name=start_logging,node=node(), + data=?abs(Dir)}), + make_all_suites_index(start), + make_all_runs_index(start), + case Mode of + interactive -> interactive_link(); + _ -> ok + end, + file:set_cwd(Dir), + make_last_run_index(Time), + CtLogFd = open_ctlog(), + io:format(CtLogFd,int_header()++int_footer(), + [log_timestamp(now()),"Common Test Logger started"]), + Parent ! {started,self(),{Time,filename:absname("")}}, + set_evmgr_gl(CtLogFd), + logger_loop(#logger_state{parent=Parent, + log_dir=Dir, + start_time=Time, + orig_GL=group_leader(), + ct_log_fd=CtLogFd, + tc_groupleaders=[]}). + +logger_loop(State) -> + receive + {log,Pid,GL,List} -> + case get_groupleader(Pid,GL,State) of + {tc_log,TCGL,TCGLs} -> + case erlang:is_process_alive(TCGL) of + true -> + %% we have to build one io-list of all strings + %% before printing, or other io printouts (made in + %% parallel) may get printed between this header + %% and footer + Fun = + fun({Str,Args},IoList) -> + case catch io_lib:format(Str,Args) of + {'EXIT',_Reason} -> + Fd = State#logger_state.ct_log_fd, + io:format(Fd, + "Logging fails! Str: ~p, Args: ~p~n", + [Str,Args]), + %% stop the testcase, we need to see the fault + exit(Pid,logging_failed), + ok; + IoStr when IoList == [] -> + [IoStr]; + IoStr -> + [IoList,"\n",IoStr] + end + end, + io:format(TCGL,"~s",[lists:foldl(Fun,[],List)]), + logger_loop(State#logger_state{tc_groupleaders=TCGLs}); + false -> + %% Group leader is dead, so write to the CtLog instead + Fd = State#logger_state.ct_log_fd, + [begin io:format(Fd,Str,Args),io:nl(Fd) end || + {Str,Args} <- List], + logger_loop(State) + end; + {ct_log,Fd,TCGLs} -> + [begin io:format(Fd,Str,Args),io:nl(Fd) end || {Str,Args} <- List], + logger_loop(State#logger_state{tc_groupleaders=TCGLs}) + end; + {{init_tc,TCPid,GL},From} -> + print_style(GL, State#logger_state.stylesheet), + set_evmgr_gl(GL), + TCGLs = add_tc_gl(TCPid,GL,State), + return(From,ok), + logger_loop(State#logger_state{tc_groupleaders=TCGLs}); + {{end_tc,TCPid},From} -> + set_evmgr_gl(State#logger_state.ct_log_fd), + return(From,ok), + logger_loop(State#logger_state{tc_groupleaders=rm_tc_gl(TCPid,State)}); + {get_log_dir,From} -> + return(From,{ok,State#logger_state.log_dir}), + logger_loop(State); + {make_last_run_index,From} -> + make_last_run_index(State#logger_state.start_time), + return(From,State#logger_state.log_dir), + logger_loop(State); + {set_stylesheet,_,SSFile} when State#logger_state.stylesheet == SSFile -> + logger_loop(State); + {set_stylesheet,TC,SSFile} -> + Fd = State#logger_state.ct_log_fd, + io:format(Fd, "~p uses external style sheet: ~s~n", [TC,SSFile]), + logger_loop(State#logger_state{stylesheet=SSFile}); + {clear_stylesheet,_} when State#logger_state.stylesheet == undefined -> + logger_loop(State); + {clear_stylesheet,_} -> + logger_loop(State#logger_state{stylesheet=undefined}); + stop -> + io:format(State#logger_state.ct_log_fd, + int_header()++int_footer(), + [log_timestamp(now()),"Common Test Logger finished"]), + close_ctlog(State#logger_state.ct_log_fd), + ok + end. + +%% #logger_state.tc_groupleaders == [{Pid,{Type,GLPid}},...] +%% Type = tc | io +%% +%% Pid can either be a test case process (tc), an IO process (io) +%% spawned by a test case process, or a common test process (never +%% registered by an init_tc msg). An IO process gets registered the +%% first time it sends data and will be stored in the list until the +%% last TC process associated with the same group leader gets +%% unregistered. +%% +%% If a process that has not been spawned by a test case process +%% sends a log request, the data will be printed to a test case +%% log file *if* there exists one registered process only in the +%% tc_groupleaders list. If multiple test case processes are +%% running, the data gets printed to the CT framework log instead. +%% +%% Note that an external process must not be registered as an IO +%% process since it could then accidentally be associated with +%% the first test case process that starts in a group of parallel +%% cases (if the log request would come in between the registration +%% of the first and second test case process). + +get_groupleader(Pid,GL,State) -> + TCGLs = State#logger_state.tc_groupleaders, + %% check if Pid is registered either as a TC or IO process + case proplists:get_value(Pid,TCGLs) of + undefined -> + %% this could be a process spawned by the test case process, + %% if so they have the same registered group leader + case lists:keysearch({tc,GL},2,TCGLs) of + {value,_} -> + %% register the io process + {tc_log,GL,[{Pid,{io,GL}}|TCGLs]}; + false -> + %% check if only one test case is executing, + %% if so return the group leader for it + case [TCGL || {_,{Type,TCGL}} <- TCGLs, Type == tc] of + [TCGL] -> + %% an external process sending the log + %% request, don't register + {tc_log,TCGL,TCGLs}; + _ -> + {ct_log,State#logger_state.ct_log_fd,TCGLs} + end + end; + {_,GL} -> + {tc_log,GL,TCGLs}; + _ -> + %% special case where a test case io process has changed + %% its group leader to an non-registered GL process + TCGLs1 = proplists:delete(Pid,TCGLs), + case [TCGL || {_,{Type,TCGL}} <- TCGLs1, Type == tc] of + [TCGL] -> + {tc_log,TCGL,TCGLs1}; + _ -> + {ct_log,State#logger_state.ct_log_fd,TCGLs1} + end + end. + +add_tc_gl(TCPid,GL,State) -> + TCGLs = State#logger_state.tc_groupleaders, + [{TCPid,{tc,GL}} | lists:keydelete(TCPid,1,TCGLs)]. + +rm_tc_gl(TCPid,State) -> + TCGLs = State#logger_state.tc_groupleaders, + case proplists:get_value(TCPid,TCGLs) of + {tc,GL} -> + TCGLs1 = lists:keydelete(TCPid,1,TCGLs), + case lists:keysearch({tc,GL},2,TCGLs1) of + {value,_} -> + %% test cases using GL remain, keep associated IO processes + TCGLs1; + false -> + %% last test case using GL, delete all associated IO processes + lists:filter(fun({_,{io,GLPid}}) when GL == GLPid -> false; + (_) -> true + end, TCGLs1) + end; + _ -> + %% add_tc_gl has not been called for this Pid, ignore + TCGLs + end. + +set_evmgr_gl(GL) -> + case whereis(?CT_EVMGR_REF) of + undefined -> ok; + EvMgrPid -> group_leader(GL,EvMgrPid) + end. + +open_ctlog() -> + {ok,Fd} = file:open(?ct_log_name,[write]), + io:format(Fd,header("Common Test Framework"),[]), + case file:consult(ct_run:variables_file_name("../")) of + {ok,Vars} -> + io:format(Fd, config_table(Vars), []); + {error,Reason} -> + {ok,Cwd} = file:get_cwd(), + Dir = filename:dirname(Cwd), + Variables = ct_run:variables_file_name(Dir), + io:format(Fd, + "Can not read the file \'~s\' Reason: ~w\n" + "No configuration found for test!!\n", + [Variables,Reason]) + end, + print_style(Fd,undefined), + io:format(Fd, + "<br><br><h2>Progress Log</h2>\n" + "<pre>\n",[]), + Fd. + +print_style(Fd,undefined) -> + io:format(Fd, + "<style>\n" + "div.ct_internal { background:lightgrey; color:black }\n" + "div.default { background:lightgreen; color:black }\n" + "</style>\n", + []); + +print_style(Fd,StyleSheet) -> + case file:read_file(StyleSheet) of + {ok,Bin} -> + Str = binary_to_list(Bin), + Pos0 = case string:str(Str,"<style>") of + 0 -> string:str(Str,"<STYLE>"); + N0 -> N0 + end, + case Pos0 of + 0 -> print_style_error(Fd,StyleSheet,missing_style_tag); + _ -> + Pos1 = case string:str(Str,"</style>") of + 0 -> string:str(Str,"</STYLE>"); + N1 -> N1 + end, + case Pos1 of + 0 -> + print_style_error(Fd,StyleSheet,missing_style_end_tag); + _ -> + Style = string:sub_string(Str,Pos0,Pos1+7), + io:format(Fd,"~s\n",[Style]) + end + end; + {error,Reason} -> + print_style_error(Fd,StyleSheet,Reason) + end. + +%% Simple link version, doesn't work with all browsers unfortunately. :-( +%% print_style(Fd, StyleSheet) -> +%% io:format(Fd, +%% "<link href=~p rel=\"stylesheet\" type=\"text/css\">", +%% [StyleSheet]). + +print_style_error(Fd,StyleSheet,Reason) -> + io:format(Fd,"\n<!-- Failed to load stylesheet ~s: ~p -->\n", + [StyleSheet,Reason]), + print_style(Fd,undefined). + +close_ctlog(Fd) -> + io:format(Fd,"</pre>",[]), + io:format(Fd,footer(),[]), + file:close(Fd). + + + +%%%----------------------------------------------------------------- +%%% Make an index page for the last run +make_last_run_index(StartTime) -> + IndexName = ?index_name, + AbsIndexName = ?abs(IndexName), + case catch make_last_run_index1(StartTime,IndexName) of + {'EXIT', Reason} -> + io:put_chars("CRASHED while updating " ++ AbsIndexName ++ "!\n"), + io:format("~p~n", [Reason]), + {error, Reason}; + {error, Reason} -> + io:put_chars("FAILED while updating " ++ AbsIndexName ++ "\n"), + io:format("~p~n", [Reason]), + {error, Reason}; + ok -> +% io:put_chars("done\n"), + ok; + Err -> + io:format("Unknown internal error while updating ~s. " + "Please report.\n(Err: ~p, ID: 1)", + [AbsIndexName,Err]), + {error, Err} + end. + +make_last_run_index1(StartTime,IndexName) -> + %% this manoeuvre is to ensure the tests get logged + %% in correct order of time (the 1 sec resolution + %% of the dirnames may be too big) + Logs1 = + case filelib:wildcard([$*|?logdir_ext]) of + [Log] -> % first test + [Log]; + Logs -> + case read_totals_file(?totals_name) of + {_Node,Logs0,_Totals} -> + insert_dirs(Logs,Logs0); + _ -> + %% someone deleted the totals file!? + Logs + end + end, + Missing = + case file:read_file(?missing_suites_info) of + {ok,Bin} -> binary_to_term(Bin); + _ -> [] + end, + {ok,Index0,Totals} = make_last_run_index(Logs1, index_header(StartTime), + 0, 0, 0, 0, 0, Missing), + %% write current Totals to file, later to be used in all_runs log + write_totals_file(?totals_name,Logs1,Totals), + Index = [Index0|index_footer()], + case force_write_file(IndexName, Index) of + ok -> + ok; + {error, Reason} -> + {error,{index_write_error, Reason}} + end. + +insert_dirs([NewDir|NewDirs],Dirs) -> + Dirs1 = insert_dir(NewDir,Dirs), + insert_dirs(NewDirs,Dirs1); +insert_dirs([],Dirs) -> + Dirs. +insert_dir(D,Dirs=[D|_]) -> + Dirs; +insert_dir(D,[D1|Ds]) -> + [D1|insert_dir(D,Ds)]; +insert_dir(D,[]) -> + [D]. + +make_last_run_index([Name|Rest], Result, TotSucc, TotFail, UserSkip, AutoSkip, + TotNotBuilt, Missing) -> + case last_test(Name) of + false -> + %% Silently skip. + make_last_run_index(Rest, Result, TotSucc, TotFail, UserSkip, AutoSkip, + TotNotBuilt, Missing); + LastLogDir -> + SuiteName = filename:rootname(filename:basename(Name)), + case make_one_index_entry(SuiteName, LastLogDir, false, Missing) of + {Result1,Succ,Fail,USkip,ASkip,NotBuilt} -> + %% for backwards compatibility + AutoSkip1 = case catch AutoSkip+ASkip of + {'EXIT',_} -> undefined; + Res -> Res + end, + make_last_run_index(Rest, [Result|Result1], TotSucc+Succ, + TotFail+Fail, UserSkip+USkip, AutoSkip1, + TotNotBuilt+NotBuilt, Missing); + error -> + make_last_run_index(Rest, Result, TotSucc, TotFail, UserSkip, AutoSkip, + TotNotBuilt, Missing) + end + end; +make_last_run_index([], Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt, _) -> + {ok, [Result|total_row(TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt, false)], + {TotSucc,TotFail,UserSkip,AutoSkip,TotNotBuilt}}. + +make_one_index_entry(SuiteName, LogDir, All, Missing) -> + case count_cases(LogDir) of + {Succ,Fail,UserSkip,AutoSkip} -> + NotBuilt = not_built(SuiteName, LogDir, All, Missing), + NewResult = make_one_index_entry1(SuiteName, LogDir, Succ, Fail, + UserSkip, AutoSkip, NotBuilt, All), + {NewResult,Succ,Fail,UserSkip,AutoSkip,NotBuilt}; + error -> + error + end. + +make_one_index_entry1(SuiteName, Link, Success, Fail, UserSkip, AutoSkip, + NotBuilt, All) -> + LogFile = filename:join(Link, ?suitelog_name ++ ".html"), + CrashDumpName = SuiteName ++ "_erl_crash.dump", + CrashDumpLink = + case filelib:is_file(CrashDumpName) of + true -> + [" <A HREF=\"", CrashDumpName, + "\">(CrashDump)</A>"]; + false -> + "" + end, + {Timestamp,Node,AllInfo} = + case All of + {true,OldRuns} -> + [_Prefix,NodeOrDate|_] = string:tokens(Link,"."), + Node1 = case string:chr(NodeOrDate,$@) of + 0 -> "-"; + _ -> NodeOrDate + end, + N = ["<TD ALIGN=right>",Node1,"</TD>\n"], + CtRunDir = filename:dirname(filename:dirname(Link)), + T = ["<TD>",timestamp(CtRunDir),"</TD>\n"], + CtLogFile = filename:join(CtRunDir,?ct_log_name), + OldRunsLink = + case OldRuns of + [] -> "none"; + _ -> "<A HREF=\""++?all_runs_name++"\">Old Runs</A>" + end, + A=["<TD><A HREF=\"",CtLogFile,"\">CT Log</A></TD>\n", + "<TD>",OldRunsLink,"</TD>\n"], + {T,N,A}; + false -> + {"","",""} + end, + NotBuiltStr = + if NotBuilt == 0 -> + ["<TD ALIGN=right>",integer_to_list(NotBuilt),"</TD>\n"]; + true -> + ["<TD ALIGN=right><A HREF=\"",?ct_log_name,"\">", + integer_to_list(NotBuilt),"</A></TD>\n"] + end, + FailStr = + if Fail > 0 -> + ["<FONT color=\"red\">", + integer_to_list(Fail),"</FONT>"]; + true -> + integer_to_list(Fail) + end, + {AllSkip,UserSkipStr,AutoSkipStr} = + if AutoSkip == undefined -> {UserSkip,"?","?"}; + true -> + ASStr = if AutoSkip > 0 -> + ["<FONT color=\"brown\">", + integer_to_list(AutoSkip),"</FONT>"]; + true -> integer_to_list(AutoSkip) + end, + {UserSkip+AutoSkip,integer_to_list(UserSkip),ASStr} + end, + ["<TR valign=top>\n", + "<TD><A HREF=\"",LogFile,"\">",SuiteName,"</A>",CrashDumpLink,"</TD>\n", + Timestamp, + "<TD ALIGN=right>",integer_to_list(Success),"</TD>\n", + "<TD ALIGN=right>",FailStr,"</TD>\n", + "<TD ALIGN=right>",integer_to_list(AllSkip), + " (",UserSkipStr,"/",AutoSkipStr,")</TD>\n", + NotBuiltStr, + Node, + AllInfo, + "</TR>\n"]. +total_row(Success, Fail, UserSkip, AutoSkip, NotBuilt, All) -> + {TimestampCell,AllInfo} = + case All of + true -> + {"<TD> </TD>\n","<TD> </TD>\n<TD> </TD>\n"}; + false -> + {"",""} + end, + + {AllSkip,UserSkipStr,AutoSkipStr} = + if AutoSkip == undefined -> {UserSkip,"?","?"}; + true -> {UserSkip+AutoSkip, + integer_to_list(UserSkip),integer_to_list(AutoSkip)} + end, + ["<TR valign=top>\n", + "<TD><B>Total</B></TD>", + TimestampCell, + "<TD ALIGN=right><B>",integer_to_list(Success),"<B></TD>\n", + "<TD ALIGN=right><B>",integer_to_list(Fail),"<B></TD>\n", + "<TD ALIGN=right>",integer_to_list(AllSkip), + " (",UserSkipStr,"/",AutoSkipStr,")</TD>\n", + "<TD ALIGN=right><B>",integer_to_list(NotBuilt),"<B></TD>\n", + AllInfo, + "</TR>\n"]. + +not_built(_BaseName,_LogDir,_All,[]) -> + 0; +not_built(BaseName,_LogDir,_All,Missing) -> + %% find out how many suites didn't compile + %% BaseName = + %% Top.ObjDir | Top.ObjDir.suites | Top.ObjDir.Suite | + %% Top.ObjDir.Suite.cases | Top.ObjDir.Suite.Case + Failed = + case string:tokens(BaseName,".") of + [T,O] when is_list(T) -> % all under Top.ObjDir + locate_info({T,O},all,Missing); + [T,O,"suites"] -> + locate_info({T,O},suites,Missing); + [T,O,S] -> + locate_info({T,O},list_to_atom(S),Missing); + [T,O,S,_] -> + locate_info({T,O},list_to_atom(S),Missing); + _ -> % old format - don't crash + [] + end, + length(Failed). + +locate_info(Path={Top,Obj},AllOrSuite,[{{Dir,Suite},Failed}|Errors]) -> + case lists:reverse(filename:split(Dir)) of + ["test",Obj,Top|_] -> + get_missing_suites(AllOrSuite,{Suite,Failed}) ++ + locate_info(Path,AllOrSuite,Errors); + [Obj,Top|_] -> + get_missing_suites(AllOrSuite,{Suite,Failed}) ++ + locate_info(Path,AllOrSuite,Errors); + _ -> + locate_info(Path,AllOrSuite,Errors) + end; +locate_info(_,_,[]) -> + []. + +get_missing_suites(all,{"all",Failed}) -> + Failed; +get_missing_suites(suites,{_Suite,Failed}) -> + Failed; +get_missing_suites(Suite,{Suite,Failed}) -> + Failed; +get_missing_suites(_,_) -> + []. + +term_to_text(Term) -> + lists:flatten(io_lib:format("~p.\n", [Term])). + + +%%% Headers and footers. + +index_header(StartTime) -> + [header("Test Results " ++ format_time(StartTime)) | + ["<CENTER>\n", + "<P><A HREF=\"",?ct_log_name,"\">Common Test Framework Log</A></P>", + "<TABLE border=\"3\" cellpadding=\"5\" " + "BGCOLOR=\"",?table_color3,"\">\n" + "<th><B>Name</B></th>\n", + "<th><font color=\"",?table_color3,"\">_</font>Ok" + "<font color=\"",?table_color3,"\">_</font></th>\n" + "<th>Failed</th>\n", + "<th>Skipped<br>(User/Auto)</th>\n" + "<th>Missing<br>Suites</th>\n" + "\n"]]. + +all_suites_index_header() -> + [header("Test Results") | + ["<CENTER>\n", + "<A HREF=\"",?all_runs_name,"\">All Test Runs in this directory</A>\n", + "<br><br>\n", + "<TABLE border=\"3\" cellpadding=\"5\" " + "BGCOLOR=\"",?table_color2,"\">\n" + "<th>Name</th>\n", + "<th>Test Run Started</th>\n", + "<th><font color=\"",?table_color2,"\">_</font>Ok" + "<font color=\"",?table_color2,"\">_</font></th>\n" + "<th>Failed</th>\n", + "<th>Skipped<br>(User/Auto)</th>\n" + "<th>Missing<br>Suites</th>\n" + "<th>Node</th>\n", + "<th>CT Log</th>\n", + "<th>Old Runs</th>\n", + "\n"]]. + +all_runs_header() -> + [header("All test runs in current directory") | + ["<CENTER><TABLE border=\"3\" cellpadding=\"5\" " + "BGCOLOR=\"",?table_color1,"\">\n" + "<th><B>History</B></th>\n" + "<th><B>Node</B></th>\n" + "<th>Tests</th>\n" + "<th><B>Names</B></th>\n" + "<th>Total</th>\n" + "<th><font color=\"",?table_color1,"\">_</font>Ok" + "<font color=\"",?table_color1,"\">_</font></th>\n" + "<th>Failed</th>\n" + "<th>Skipped<br>(User/Auto)</th>\n" + "<th>Missing<br>Suites</th>\n" + "\n"]]. + +header(Title) -> + ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n" + "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n" + "<HTML>\n", + "<HEAD>\n", + + "<TITLE>" ++ Title ++ "</TITLE>\n", + "<META HTTP-EQUIV=\"CACHE-CONTROL\" CONTENT=\"NO-CACHE\">\n", + + "</HEAD>\n", + + body_tag(), + + "<!-- ---- DOCUMENT TITLE ---- -->\n", + + "<CENTER>\n", + "<H1>" ++ Title ++ "</H1>\n", + "</CENTER>\n", + + "<!-- ---- CONTENT ---- -->\n"]. + +index_footer() -> + ["</TABLE>\n" + "</CENTER>\n" | footer()]. + +footer() -> + ["<P><CENTER>\n" + "<HR>\n" + "<P><FONT SIZE=-1>\n" + "Copyright © ", year(), + " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n" + "Updated: <!date>", current_time(), "<!/date><BR>\n" + "</FONT>\n" + "</CENTER>\n" + "</body>\n"]. + + +body_tag() -> + "<body bgcolor=\"#FFFFFF\" text=\"#000000\" link=\"#0000FF\"" + "vlink=\"#800080\" alink=\"#FF0000\">\n". + +current_time() -> + format_time(calendar:local_time()). + +format_time({{Y, Mon, D}, {H, Min, S}}) -> + Weekday = weekday(calendar:day_of_the_week(Y, Mon, D)), + lists:flatten(io_lib:format("~s ~s ~p ~w ~2.2.0w:~2.2.0w:~2.2.0w", + [Weekday, month(Mon), D, Y, H, Min, S])). + +weekday(1) -> "Mon"; +weekday(2) -> "Tue"; +weekday(3) -> "Wed"; +weekday(4) -> "Thu"; +weekday(5) -> "Fri"; +weekday(6) -> "Sat"; +weekday(7) -> "Sun". + +month(1) -> "Jan"; +month(2) -> "Feb"; +month(3) -> "Mar"; +month(4) -> "Apr"; +month(5) -> "May"; +month(6) -> "Jun"; +month(7) -> "Jul"; +month(8) -> "Aug"; +month(9) -> "Sep"; +month(10) -> "Oct"; +month(11) -> "Nov"; +month(12) -> "Dec". + +year() -> + {Y, _, _} = date(), + integer_to_list(Y). + + +%% Count test cases in the given directory (a directory of the type +%% run.1997-08-04_09.58.52). + +count_cases(Dir) -> + SumFile = filename:join(Dir, ?run_summary), + case read_summary(SumFile, [summary]) of + {ok, [{Succ,Fail,Skip}]} -> + {Succ,Fail,Skip,undefined}; + {ok, [Summary]} -> + Summary; + {error, _} -> + LogFile = filename:join(Dir, ?suitelog_name), + case file:read_file(LogFile) of + {ok, Bin} -> + case count_cases1(binary_to_list(Bin), + {undefined,undefined,undefined,undefined}) of + {error,not_complete} -> + %% The test is not complete - dont write summary + %% file yet. + {0,0,0,0}; + Summary -> + write_summary(SumFile, Summary), + Summary + end; + {error, _Reason} -> + io:format("\nFailed to read ~p (skipped)\n", [LogFile]), + error + end + end. + +write_summary(Name, Summary) -> + File = [term_to_text({summary, Summary})], + force_write_file(Name, File). + +read_summary(Name, Keys) -> + case file:consult(Name) of + {ok, []} -> + {error, "Empty summary file"}; + {ok, Terms} -> + {ok, lists:map(fun(Key) -> {value, {_, Value}} = + lists:keysearch(Key, 1, Terms), + Value end, + Keys)}; + {error, Reason} -> + {error, Reason} + end. + +count_cases1("=failed" ++ Rest, {Success, _Fail, UserSkip,AutoSkip}) -> + {NextLine, Count} = get_number(Rest), + count_cases1(NextLine, {Success, Count, UserSkip,AutoSkip}); +count_cases1("=successful" ++ Rest, {_Success, Fail, UserSkip,AutoSkip}) -> + {NextLine, Count} = get_number(Rest), + count_cases1(NextLine, {Count, Fail, UserSkip,AutoSkip}); +count_cases1("=skipped" ++ Rest, {Success, Fail, _UserSkip,_AutoSkip}) -> + {NextLine, Count} = get_number(Rest), + count_cases1(NextLine, {Success, Fail, Count,undefined}); +count_cases1("=user_skipped" ++ Rest, {Success, Fail, _UserSkip,AutoSkip}) -> + {NextLine, Count} = get_number(Rest), + count_cases1(NextLine, {Success, Fail, Count,AutoSkip}); +count_cases1("=auto_skipped" ++ Rest, {Success, Fail, UserSkip,_AutoSkip}) -> + {NextLine, Count} = get_number(Rest), + count_cases1(NextLine, {Success, Fail, UserSkip,Count}); +count_cases1([], {Su,F,USk,_ASk}) when Su==undefined;F==undefined; + USk==undefined -> + {error,not_complete}; +count_cases1([], Counters) -> + Counters; +count_cases1(Other, Counters) -> + count_cases1(skip_to_nl(Other), Counters). + +get_number([$\s|Rest]) -> + get_number(Rest); +get_number([Digit|Rest]) when $0 =< Digit, Digit =< $9 -> + get_number(Rest, Digit-$0). + +get_number([Digit|Rest], Acc) when $0 =< Digit, Digit =< $9 -> + get_number(Rest, Acc*10+Digit-$0); +get_number([$\n|Rest], Acc) -> + {Rest, Acc}; +get_number([_|Rest], Acc) -> + get_number(Rest, Acc). + +skip_to_nl([$\n|Rest]) -> + Rest; +skip_to_nl([_|Rest]) -> + skip_to_nl(Rest); +skip_to_nl([]) -> + []. + + +config_table(Vars) -> + [config_table_header()|config_table1(Vars)]. + +config_table_header() -> + ["<h2>Configuration</h2>\n", + "<table border=\"3\" cellpadding=\"5\" bgcolor=\"",?table_color1, + "\"\n", + "<tr><th>Key</th><th>Value</th></tr>\n"]. + +config_table1([{Key,Value}|Vars]) -> + ["<tr><td>", atom_to_list(Key), "</td>\n", + "<td><pre>",io_lib:format("~p",[Value]),"</pre></td></tr>\n" | + config_table1(Vars)]; +config_table1([]) -> + ["</table>\n"]. + + +make_all_runs_index(When) -> + AbsName = ?abs(?all_runs_name), + notify_and_lock_file(AbsName), + if When == start -> ok; + true -> io:put_chars("Updating " ++ AbsName ++ "... ") + end, + Dirs = filelib:wildcard(logdir_prefix()++"*.*"), + DirsSorted = (catch sort_all_runs(Dirs)), + Header = all_runs_header(), + BasicHtml = basic_html(), + Index = [runentry(Dir, BasicHtml) || Dir <- DirsSorted], + Result = file:write_file(AbsName,Header++Index++index_footer()), + if When == start -> ok; + true -> io:put_chars("done\n") + end, + notify_and_unlock_file(AbsName), + Result. + +sort_all_runs(Dirs) -> + %% sort on time string, always last and on the format: + %% "YYYY-MM-DD_HH.MM.SS" + KeyList = + lists:map(fun(Dir) -> + case lists:reverse(string:tokens(Dir,[$.,$_])) of + [SS,MM,HH,Date|_] -> + {{Date,HH,MM,SS},Dir}; + _Other -> + throw(Dirs) + end + end,Dirs), + lists:reverse(lists:map(fun({_,Dir}) -> + Dir + end,lists:keysort(1,KeyList))). + + +interactive_link() -> + [Dir|_] = lists:reverse(filelib:wildcard(logdir_prefix()++"*.*")), + CtLog = filename:join(Dir,"ctlog.html"), + Body = ["Log from last interactive run: <A HREF=\"",CtLog,"\">", + timestamp(Dir),"</A>"], + file:write_file("last_interactive.html",Body), + io:format("~n~nUpdated ~s\n" + "Any CT activities will be logged here\n", + [?abs("last_interactive.html")]). + +runentry(Dir, BasicHtml) -> + TotalsFile = filename:join(Dir,?totals_name), + TotalsStr = + case read_totals_file(TotalsFile) of + {Node,Logs,{TotSucc,TotFail,UserSkip,AutoSkip,NotBuilt}} -> + TotFailStr = + if TotFail > 0 -> + ["<FONT color=\"red\">", + integer_to_list(TotFail),"</FONT>"]; + true -> + integer_to_list(TotFail) + end, + {AllSkip,UserSkipStr,AutoSkipStr} = + if AutoSkip == undefined -> {UserSkip,"?","?"}; + true -> + ASStr = if AutoSkip > 0 -> + ["<FONT color=\"brown\">", + integer_to_list(AutoSkip),"</FONT>"]; + true -> integer_to_list(AutoSkip) + end, + {UserSkip+AutoSkip,integer_to_list(UserSkip),ASStr} + end, + NoOfTests = case length(Logs) of + 0 -> "-"; + N -> integer_to_list(N) + end, + StripExt = + fun(File) -> + string:sub_string(File,1, + length(File)- + length(?logdir_ext)) ++ ", " + end, + Polish = fun(S) -> case lists:reverse(S) of + [32,$,|Rev] -> lists:reverse(Rev); + [$,|Rev] -> lists:reverse(Rev); + _ -> S + end + end, + TestNames = Polish(lists:flatten(lists:map(StripExt,Logs))), + TestNamesTrunc = + if TestNames=="" -> + ""; + length(TestNames) < ?testname_width -> + TestNames; + true -> + Trunc = Polish(string:substr(TestNames,1,?testname_width-3)), + lists:flatten(io_lib:format("~s...",[Trunc])) + end, + Total = TotSucc+TotFail+AllSkip, + A = ["<TD ALIGN=center><FONT SIZE=-1>",Node,"</FONT></TD>\n", + "<TD ALIGN=right>",NoOfTests,"</TD>\n"], + B = if BasicHtml -> + ["<TD ALIGN=center><FONT SIZE=-1>",TestNamesTrunc,"</FONT></TD>\n"]; + true -> + ["<TD ALIGN=center TITLE='",TestNames,"'><FONT SIZE=-1> ", + TestNamesTrunc,"</FONT></TD>\n"] + end, + C = ["<TD ALIGN=right>",integer_to_list(Total),"</TD>\n", + "<TD ALIGN=right>",integer_to_list(TotSucc),"</TD>\n", + "<TD ALIGN=right>",TotFailStr,"</TD>\n", + "<TD ALIGN=right>",integer_to_list(AllSkip), + " (",UserSkipStr,"/",AutoSkipStr,")</TD>\n", + "<TD ALIGN=right>",integer_to_list(NotBuilt),"</TD>\n"], + A++B++C; + _ -> + ["<TD ALIGN=center><FONT size=-1 color=\"red\">", + "Test data missing or corrupt","</FONT></TD>\n"] + end, + Index = filename:join(Dir,?index_name), + ["<TR>\n" + "<TD><A HREF=\"",Index,"\">",timestamp(Dir),"</A>",TotalsStr,"</TD>\n" + "</TR>\n"]. + +write_totals_file(Name,Logs,Totals) -> + AbsName = ?abs(Name), + notify_and_lock_file(AbsName), + force_write_file(AbsName, + term_to_binary({atom_to_list(node()), + Logs,Totals})), + notify_and_unlock_file(AbsName). + +read_totals_file(Name) -> + AbsName = ?abs(Name), + notify_and_lock_file(AbsName), + Result = + case file:read_file(AbsName) of + {ok,Bin} -> + case catch binary_to_term(Bin) of + {'EXIT',_Reason} -> % corrupt file + {"-",[],undefined}; + R = {Node,Ls,Tot} -> + case Tot of + {_,_,_,_,_} -> % latest format + R; + {TotSucc,TotFail,AllSkip,NotBuilt} -> + {Node,Ls,{TotSucc,TotFail,AllSkip,undefined,NotBuilt}} + end; + %% for backwards compatibility + {Ls,Tot} -> {"-",Ls,Tot}; + Tot -> {"-",[],Tot} + end; + Error -> + Error + end, + notify_and_unlock_file(AbsName), + Result. + +force_write_file(Name,Contents) -> + force_delete(Name), + file:write_file(Name,Contents). + +force_delete(Name) -> + case file:delete(Name) of + {error,eacces} -> + force_rename(Name,Name++".old.",0); + Other -> + Other + end. + +force_rename(From,To,Number) -> + Dest = [To|integer_to_list(Number)], + case file:read_file_info(Dest) of + {ok,_} -> + force_rename(From,To,Number+1); + {error,_} -> + file:rename(From,Dest) + end. + + +timestamp(Dir) -> + TsR = lists:reverse(string:tokens(Dir,".-_")), + [S,Min,H,D,M,Y] = [list_to_integer(N) || N <- lists:sublist(TsR,6)], + format_time({{Y,M,D},{H,Min,S}}). + +make_all_suites_index(When) -> + AbsIndexName = ?abs(?index_name), + notify_and_lock_file(AbsIndexName), + LogDirs = filelib:wildcard(logdir_prefix()++".*/*"++?logdir_ext), + Sorted = sort_logdirs(LogDirs,[]), + Result = make_all_suites_index1(When,Sorted), + notify_and_unlock_file(AbsIndexName), + Result. + +sort_logdirs([Dir|Dirs],Groups) -> + TestName = filename:rootname(filename:basename(Dir)), + case filelib:wildcard(filename:join(Dir,"run.*")) of + [RunDir] -> + Groups1 = insert_test(TestName,{filename:basename(RunDir),RunDir},Groups), + sort_logdirs(Dirs,Groups1); + _ -> % ignore missing run directory + sort_logdirs(Dirs,Groups) + end; +sort_logdirs([],Groups) -> + lists:keysort(1,sort_each_group(Groups)). + +insert_test(Test,IxDir,[{Test,IxDirs}|Groups]) -> + [{Test,[IxDir|IxDirs]}|Groups]; +insert_test(Test,IxDir,[]) -> + [{Test,[IxDir]}]; +insert_test(Test,IxDir,[TestDir|Groups]) -> + [TestDir|insert_test(Test,IxDir,Groups)]. + +sort_each_group([{Test,IxDirs}|Groups]) -> + Sorted = lists:reverse([Dir || {_,Dir} <- lists:keysort(1,IxDirs)]), + [{Test,Sorted}| sort_each_group(Groups)]; +sort_each_group([]) -> + []. + +make_all_suites_index1(When,AllSuitesLogDirs) -> + IndexName = ?index_name, + AbsIndexName = ?abs(IndexName), + if When == start -> ok; + true -> io:put_chars("Updating " ++ AbsIndexName ++ "... ") + end, + case catch make_all_suites_index2(IndexName,AllSuitesLogDirs) of + {'EXIT', Reason} -> + io:put_chars("CRASHED while updating " ++ AbsIndexName ++ "!\n"), + io:format("~p~n", [Reason]), + {error, Reason}; + {error, Reason} -> + io:put_chars("FAILED while updating " ++ AbsIndexName ++ "\n"), + io:format("~p~n", [Reason]), + {error, Reason}; + ok -> + if When == start -> ok; + true -> io:put_chars("done\n") + end, + ok; + Err -> + io:format("Unknown internal error while updating ~s. " + "Please report.\n(Err: ~p, ID: 1)", + [AbsIndexName,Err]), + {error, Err} + end. + +make_all_suites_index2(IndexName,AllSuitesLogDirs) -> + {ok,Index0,_Totals} = make_all_suites_index3(AllSuitesLogDirs, + all_suites_index_header(), + 0, 0, 0, 0, 0), + Index = [Index0|index_footer()], + case force_write_file(IndexName, Index) of + ok -> + ok; + {error, Reason} -> + {error,{index_write_error, Reason}} + end. + +make_all_suites_index3([{SuiteName,[LastLogDir|OldDirs]}|Rest], + Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt) -> + [EntryDir|_] = filename:split(LastLogDir), + Missing = + case file:read_file(filename:join(EntryDir,?missing_suites_info)) of + {ok,Bin} -> binary_to_term(Bin); + _ -> [] + end, + case make_one_index_entry(SuiteName, LastLogDir, {true,OldDirs}, Missing) of + {Result1,Succ,Fail,USkip,ASkip,NotBuilt} -> + %% for backwards compatibility + AutoSkip1 = case catch AutoSkip+ASkip of + {'EXIT',_} -> undefined; + Res -> Res + end, + make_all_suites_index3(Rest, [Result|Result1], TotSucc+Succ, + TotFail+Fail, UserSkip+USkip, AutoSkip1, + TotNotBuilt+NotBuilt); + error -> + make_all_suites_index3(Rest, Result, TotSucc, TotFail, + UserSkip, AutoSkip, TotNotBuilt) + end; +make_all_suites_index3([], Result, TotSucc, TotFail, UserSkip, AutoSkip, + TotNotBuilt) -> + {ok, [Result|total_row(TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt,true)], + {TotSucc,TotFail,UserSkip,AutoSkip,TotNotBuilt}}. + + +%%----------------------------------------------------------------- +%% Remove log files. +%% Cwd should always be set to the root logdir when finished. +cleanup() -> + {ok,Cwd} = file:get_cwd(), + ok = file:set_cwd("../"), + {ok,Top} = file:get_cwd(), + Result = + case catch try_cleanup(Cwd) of + ok -> + ok; + {'EXIT',Reason} -> + {error,Reason}; + Error -> + {error,Error} + end, + ok = file:set_cwd(Top), + Result. + +try_cleanup(CTRunDir) -> + %% ensure we're removing the ct_run directory + case lists:reverse(filename:split(CTRunDir)) of + [[$c,$t,$_,$r,$u,$n,$.|_]|_] -> + case filelib:wildcard(filename:join(CTRunDir,"ct_run.*")) of + [] -> % "double check" + rm_dir(CTRunDir); + _ -> + unknown_logdir + end; + _ -> + unknown_logdir + end. + +rm_dir(Dir) -> + case file:list_dir(Dir) of + {error,Errno} -> + exit({ls_failed,Dir,Errno}); + {ok,Files} -> + rm_files([filename:join(Dir, F) || F <- Files]), + case file:del_dir(Dir) of + {error,Errno} -> + exit({rmdir_failed,Errno}); + ok -> + ok + end + end. + +rm_files([F | Fs]) -> + Base = filename:basename(F), + if Base == "." ; Base == ".." -> + rm_files(Fs); + true -> + case file:read_file_info(F) of + {ok,#file_info{type=directory}} -> + rm_dir(F), + rm_files(Fs); + {ok,_Regular} -> + case file:delete(F) of + ok -> + rm_files(Fs); + {error,Errno} -> + exit({del_failed,F,Errno}) + end + end + end; +rm_files([]) -> + ok. + +%%%----------------------------------------------------------------- +%%% @spec simulate() -> pid() +%%% +%%% @doc Simulate the logger process. +%%% +%%% <p>Simulate the logger process - for use when testing code using +%%% ct_logs logging mechanism without using the ct +%%% environment. (E.g. when testing code with ts)</p> +simulate() -> + cast(stop), + S = self(), + Pid = spawn(fun() -> + register(?MODULE,self()), + S ! {self(),started}, + simulate_logger_loop() + end), + receive {Pid,started} -> Pid end. + + +simulate_logger_loop() -> + receive + {log,_,_,List} -> + S = [[io_lib:format(Str,Args),io_lib:nl()] || {Str,Args} <- List], + io:format("~s",[S]), + simulate_logger_loop(); + stop -> + ok + end. + +%%%----------------------------------------------------------------- +%%% @spec notify_and_lock_file(Files) -> ok +%%% +%%% @doc +%%% +notify_and_lock_file(File) -> + case ct_event:is_alive() of + true -> + ct_event:sync_notify(#event{name=start_write_file, + node=node(), + data=File}); + false -> + ok + end. + +%%%----------------------------------------------------------------- +%%% @spec notify_and_unlock_file(Files) -> ok +%%% +%%% @doc +%%% +notify_and_unlock_file(File) -> + case ct_event:is_alive() of + true -> + ct_event:sync_notify(#event{name=finished_write_file, + node=node(), + data=File}); + false -> + ok + end. + +%%%----------------------------------------------------------------- +%%% @spec last_test(Dir) -> string() | false +%%% +%%% @doc +%%% +last_test(Dir) -> + last_test(filelib:wildcard(filename:join(Dir, "run.[1-2]*")), false). + +last_test([Run|Rest], false) -> + last_test(Rest, Run); +last_test([Run|Rest], Latest) when Run > Latest -> + last_test(Rest, Run); +last_test([_|Rest], Latest) -> + last_test(Rest, Latest); +last_test([], Latest) -> + Latest. + +%%%----------------------------------------------------------------- +%%% @spec basic_html() -> true | false +%%% +%%% @doc +%%% +basic_html() -> + case application:get_env(common_test, basic_html) of + {ok,true} -> + true; + _ -> + false + end. diff --git a/lib/common_test/src/ct_make.erl b/lib/common_test/src/ct_make.erl new file mode 100644 index 0000000000..233e45248e --- /dev/null +++ b/lib/common_test/src/ct_make.erl @@ -0,0 +1,344 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%% +%% Purpose : Basic make facility for Common Test +%% +%% Compares date stamps of .erl and Object files - recompiles when +%% necessary. +%% Files to be checked are contained in a file 'Emakefile' +%% If Emakefile is missing the current directory is used. +%% + +-module(ct_make). + +-export([all/0,all/1,files/1,files/2]). + +-include_lib("kernel/include/file.hrl"). + +-define(MakeOpts,[noexec,load,netload,noload]). + +all() -> + all([]). + +all(Options) -> + {MakeOpts,CompileOpts} = sort_options(Options,[],[]), + case read_emakefile('Emakefile',CompileOpts) of + Files when is_list(Files) -> + do_make_files(Files,MakeOpts); + error -> + {error,[]} + end. + +files(Fs) -> + files(Fs, []). + +files(Fs0, Options) -> + Fs = [filename:rootname(F,".erl") || F <- Fs0], + {MakeOpts,CompileOpts} = sort_options(Options,[],[]), + case get_opts_from_emakefile(Fs,'Emakefile',CompileOpts) of + Files when is_list(Files) -> + do_make_files(Files,MakeOpts); + error -> + {error,[]} + end. + +do_make_files(Fs, Opts) -> + process(Fs, lists:member(noexec, Opts), load_opt(Opts), []). + + +sort_options([H|T],Make,Comp) -> + case lists:member(H,?MakeOpts) of + true -> + sort_options(T,[H|Make],Comp); + false -> + sort_options(T,Make,[H|Comp]) + end; +sort_options([],Make,Comp) -> + {Make,lists:reverse(Comp)}. + +%%% Reads the given Emakefile and returns a list of tuples: {Mods,Opts} +%%% Mods is a list of module names (strings) +%%% Opts is a list of options to be used when compiling Mods +%%% +%%% Emakefile can contain elements like this: +%%% Mod. +%%% {Mod,Opts}. +%%% Mod is a module name which might include '*' as wildcard +%%% or a list of such module names +%%% +%%% These elements are converted to [{ModList,OptList},...] +%%% ModList is a list of modulenames (strings) +read_emakefile(Emakefile,Opts) -> + case file:consult(Emakefile) of + {ok,Emake} -> + transform(Emake,Opts,[],[]); + {error,enoent} -> + %% No Emakefile found - return all modules in current + %% directory and the options given at command line + Mods = [filename:rootname(F) || F <- filelib:wildcard("*.erl")], + [{Mods, Opts}]; + {error,Other} -> + io:format("make: Trouble reading 'Emakefile':~n~p~n",[Other]), + error + end. + +transform([{Mod,ModOpts}|Emake],Opts,Files,Already) -> + case expand(Mod,Already) of + [] -> + transform(Emake,Opts,Files,Already); + Mods -> + transform(Emake,Opts,[{Mods,ModOpts++Opts}|Files],Mods++Already) + end; +transform([Mod|Emake],Opts,Files,Already) -> + case expand(Mod,Already) of + [] -> + transform(Emake,Opts,Files,Already); + Mods -> + transform(Emake,Opts,[{Mods,Opts}|Files],Mods++Already) + end; +transform([],_Opts,Files,_Already) -> + lists:reverse(Files). + +expand(Mod,Already) when is_atom(Mod) -> + expand(atom_to_list(Mod),Already); +expand(Mods,Already) when is_list(Mods), not is_integer(hd(Mods)) -> + lists:concat([expand(Mod,Already) || Mod <- Mods]); +expand(Mod,Already) -> + case lists:member($*,Mod) of + true -> + Fun = fun(F,Acc) -> + M = filename:rootname(F), + case lists:member(M,Already) of + true -> Acc; + false -> [M|Acc] + end + end, + lists:foldl(Fun, [], filelib:wildcard(Mod++".erl")); + false -> + Mod2 = filename:rootname(Mod, ".erl"), + case lists:member(Mod2,Already) of + true -> []; + false -> [Mod2] + end + end. + +%%% Reads the given Emakefile to see if there are any specific compile +%%% options given for the modules. +get_opts_from_emakefile(Mods,Emakefile,Opts) -> + case file:consult(Emakefile) of + {ok,Emake} -> + Modsandopts = transform(Emake,Opts,[],[]), + ModStrings = [coerce_2_list(M) || M <- Mods], + get_opts_from_emakefile2(Modsandopts,ModStrings,Opts,[]); + {error,enoent} -> + [{Mods, Opts}]; + {error,Other} -> + io:format("make: Trouble reading 'Emakefile':~n~p~n",[Other]), + error + end. + +get_opts_from_emakefile2([{MakefileMods,O}|Rest],Mods,Opts,Result) -> + case members(Mods,MakefileMods,[],Mods) of + {[],_} -> + get_opts_from_emakefile2(Rest,Mods,Opts,Result); + {I,RestOfMods} -> + get_opts_from_emakefile2(Rest,RestOfMods,Opts,[{I,O}|Result]) + end; +get_opts_from_emakefile2([],[],_Opts,Result) -> + Result; +get_opts_from_emakefile2([],RestOfMods,Opts,Result) -> + [{RestOfMods,Opts}|Result]. + +members([H|T],MakefileMods,I,Rest) -> + case lists:member(H,MakefileMods) of + true -> + members(T,MakefileMods,[H|I],lists:delete(H,Rest)); + false -> + members(T,MakefileMods,I,Rest) + end; +members([],_MakefileMods,I,Rest) -> + {I,Rest}. + + +%% Any flags that are not recognixed as make flags are passed directly +%% to the compiler. +%% So for example make:all([load,debug_info]) will make everything +%% with the debug_info flag and load it. + +load_opt(Opts) -> + case lists:member(netload,Opts) of + true -> + netload; + false -> + case lists:member(load,Opts) of + true -> + load; + _ -> + noload + end + end. + + +process([{[],_Opts}|Rest], NoExec, Load, Result) -> + process(Rest, NoExec, Load, Result); +process([{[H|T],Opts}|Rest], NoExec, Load, Result) -> + case recompilep(coerce_2_list(H), NoExec, Load, Opts) of + error -> + process([{T,Opts}|Rest], NoExec, Load, [{H,error}|Result]); + Info -> + process([{T,Opts}|Rest], NoExec, Load, [{H,Info}|Result]) + end; +process([], NoExec, _Load, Result) -> + if not NoExec -> + case lists:keysearch(error, 2, Result) of + {value,_} -> + {error,Result}; + false -> + {up_to_date,Result} + end; + true -> + Result + end. + +recompilep(File, NoExec, Load, Opts) -> + ObjName = lists:append(filename:basename(File), + code:objfile_extension()), + ObjFile = case lists:keysearch(outdir,1,Opts) of + {value,{outdir,OutDir}} -> + filename:join(coerce_2_list(OutDir),ObjName); + false -> + ObjName + end, + case exists(ObjFile) of + true -> + recompilep1(File, NoExec, Load, Opts, ObjFile); + false -> + recompile(File, NoExec, Load, Opts) + end. + +recompilep1(File, NoExec, Load, Opts, ObjFile) -> + {ok, Erl} = file:read_file_info(lists:append(File, ".erl")), + {ok, Obj} = file:read_file_info(ObjFile), + case {readable(Erl), writable(Obj)} of + {true, true} -> + recompilep1(Erl, Obj, File, NoExec, Load, Opts); + _ -> + error + end. + +recompilep1(#file_info{mtime=Te}, + #file_info{mtime=To}, File, NoExec, Load, Opts) when Te>To -> + recompile(File, NoExec, Load, Opts); +recompilep1(_Erl, #file_info{mtime=To}, File, NoExec, Load, Opts) -> + recompile2(To, File, NoExec, Load, Opts). + +%% recompile2(ObjMTime, File, NoExec, Load, Opts) +%% Check if file is of a later date than include files. +recompile2(ObjMTime, File, NoExec, Load, Opts) -> + IncludePath = include_opt(Opts), + case check_includes(lists:append(File, ".erl"), IncludePath, ObjMTime) of + true -> + recompile(File, NoExec, Load, Opts); + false -> + up_to_date + end. + +include_opt([{i,Path}|Rest]) -> + [Path|include_opt(Rest)]; +include_opt([_First|Rest]) -> + include_opt(Rest); +include_opt([]) -> + []. + +%% recompile(File, NoExec, Load, Opts) +%% Actually recompile and load the file, depending on the flags. +%% Where load can be netload | load | noload + +recompile(File, NoExec, Load, Opts) -> + case do_recompile(File, NoExec, Load, Opts) of + {ok,_} -> ok; + Other -> Other + end. + +do_recompile(_File, true, _Load, _Opts) -> + out_of_date; +do_recompile(File, false, noload, Opts) -> + io:format("Recompile: ~s\n",[File]), + compile:file(File, [report_errors, report_warnings, error_summary |Opts]); +do_recompile(File, false, load, Opts) -> + io:format("Recompile: ~s\n",[File]), + c:c(File, Opts); +do_recompile(File, false, netload, Opts) -> + io:format("Recompile: ~s\n",[File]), + c:nc(File, Opts). + +exists(File) -> + case file:read_file_info(File) of + {ok, _} -> + true; + _ -> + false + end. + +readable(#file_info{access=read_write}) -> true; +readable(#file_info{access=read}) -> true; +readable(_) -> false. + +writable(#file_info{access=read_write}) -> true; +writable(#file_info{access=write}) -> true; +writable(_) -> false. + +coerce_2_list(X) when is_atom(X) -> + atom_to_list(X); +coerce_2_list(X) -> + X. + +%%% If you an include file is found with a modification +%%% time larger than the modification time of the object +%%% file, return true. Otherwise return false. +check_includes(File, IncludePath, ObjMTime) -> + Path = [filename:dirname(File)|IncludePath], + case epp:open(File, Path, []) of + {ok, Epp} -> + check_includes2(Epp, File, ObjMTime); + _Error -> + false + end. + +check_includes2(Epp, File, ObjMTime) -> + case epp:parse_erl_form(Epp) of + {ok, {attribute, 1, file, {File, 1}}} -> + check_includes2(Epp, File, ObjMTime); + {ok, {attribute, 1, file, {IncFile, 1}}} -> + case file:read_file_info(IncFile) of + {ok, #file_info{mtime=MTime}} when MTime>ObjMTime -> + epp:close(Epp), + true; + _ -> + check_includes2(Epp, File, ObjMTime) + end; + {ok, _} -> + check_includes2(Epp, File, ObjMTime); + {eof, _} -> + epp:close(Epp), + false; + {error, _Error} -> + check_includes2(Epp, File, ObjMTime) + end. diff --git a/lib/common_test/src/ct_master.erl b/lib/common_test/src/ct_master.erl new file mode 100644 index 0000000000..7eb2c3cfef --- /dev/null +++ b/lib/common_test/src/ct_master.erl @@ -0,0 +1,696 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Distributed test execution control for Common Test. +%%% <p>This module exports functions for running Common Test nodes +%%% on multiple hosts in parallel.</p> +-module(ct_master). + +-export([run/1,run/3,run/4]). +-export([run_on_node/2,run_on_node/3]). +-export([run_test/1,run_test/2]). + +-export([abort/0,abort/1,progress/0]). + +-export([init_master/6, init_node_ctrl/3]). + +-export([status/2]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). + +-record(state, {node_ctrl_pids=[], + logdirs=[], + results=[], + locks=[], + blocked=[] + }). + +%%%----------------------------------------------------------------- +%%% @spec run_test(Node,Opts) -> ok +%%% Node = atom() +%%% Opts = [OptTuples] +%%% OptTuples = {config,CfgFiles} | {dir,TestDirs} | {suite,Suites} | +%%% {testcase,Cases} | {spec,TestSpecs} | {allow_user_terms,Bool} | +%%% {logdir,LogDir} | {event_handler,EventHandlers} | +%%% {silent_connections,Conns} | {cover,CoverSpecFile} +%%% CfgFiles = string() | [string()] +%%% TestDirs = string() | [string()] +%%% Suites = atom() | [atom()] +%%% Cases = atom() | [atom()] +%%% TestSpecs = string() | [string()] +%%% LogDir = string() +%%% EventHandlers = EH | [EH] +%%% EH = atom() | {atom(),InitArgs} | {[atom()],InitArgs} +%%% InitArgs = [term()] +%%% Conns = all | [atom()] +%%% +%%% @doc Tests are spawned on <code>Node</code> using <code>ct:run_test/1</code>. +run_test(Node,Opts) -> + run_test([{Node,Opts}]). + +%%% @hidden +run_test({Node,Opts}) -> + run_test([{Node,Opts}]); +run_test(NodeOptsList) when is_list(NodeOptsList) -> + start_master(NodeOptsList). + +%%%----------------------------------------------------------------- +%%% @spec run(TestSpecs,AllowUserTerms,InclNodes,ExclNodes) -> ok +%%% TestSpecs = string() | [SeparateOrMerged] +%%% SeparateOrMerged = string() | [string()] +%%% AllowUserTerms = bool() +%%% InclNodes = [atom()] +%%% ExclNodes = [atom()] +%%% +%%% @doc Tests are spawned on the nodes as specified in <code>TestSpecs</code>. +%%% Each specification in TestSpec will be handled separately. It is however possible +%%% to also specify a list of specifications that should be merged into one before +%%% the tests are executed. Any test without a particular node specification will +%%% also be executed on the nodes in <code>InclNodes</code>. Nodes in the +%%% <code>ExclNodes</code> list will be excluded from the test. +run([TS|TestSpecs],AllowUserTerms,InclNodes,ExclNodes) when is_list(TS), + is_list(InclNodes), + is_list(ExclNodes) -> + TS1 = + case TS of + List=[S|_] when is_list(S) -> List; + Spec -> [Spec] + end, + Result = + case catch ct_testspec:collect_tests_from_file(TS1,InclNodes,AllowUserTerms) of + {error,Reason} -> + {error,Reason}; + TSRec=#testspec{logdir=AllLogDirs, + config=AllCfgFiles, + event_handler=AllEvHs} -> + RunSkipPerNode = ct_testspec:prepare_tests(TSRec), + RunSkipPerNode2 = exclude_nodes(ExclNodes,RunSkipPerNode), + run_all(RunSkipPerNode2,AllLogDirs,AllCfgFiles,AllEvHs,[],[],TS1) + end, + [{TS,Result} | run(TestSpecs,AllowUserTerms,InclNodes,ExclNodes)]; +run([],_,_,_) -> + []; +run(TS,AllowUserTerms,InclNodes,ExclNodes) when is_list(InclNodes), is_list(ExclNodes) -> + run([TS],AllowUserTerms,InclNodes,ExclNodes). + +%%%----------------------------------------------------------------- +%%% @spec run(TestSpecs,InclNodes,ExclNodes) -> ok +%%% TestSpecs = string() | [SeparateOrMerged] +%%% SeparateOrMerged = string() | [string()] +%%% InclNodes = [atom()] +%%% ExclNodes = [atom()] +%%% +%%% @equiv run(TestSpecs,false,InclNodes,ExclNodes) +run(TestSpecs,InclNodes,ExclNodes) -> + run(TestSpecs,false,InclNodes,ExclNodes). + +%%%----------------------------------------------------------------- +%%% @spec run(TestSpecs) -> ok +%%% TestSpecs = string() | [SeparateOrMerged] +%%% +%%% @equiv run(TestSpecs,false,[],[]) +run(TestSpecs=[TS|_]) when is_list(TS) -> + run(TestSpecs,false,[],[]); +run(TS) -> + run([TS],false,[],[]). + + +exclude_nodes([ExclNode|ExNs],RunSkipPerNode) -> + exclude_nodes(ExNs,lists:keydelete(ExclNode,1,RunSkipPerNode)); +exclude_nodes([],RunSkipPerNode) -> + RunSkipPerNode. + + +%%%----------------------------------------------------------------- +%%% @spec run_on_node(TestSpecs,AllowUserTerms,Node) -> ok +%%% TestSpecs = string() | [SeparateOrMerged] +%%% SeparateOrMerged = string() | [string()] +%%% AllowUserTerms = bool() +%%% Node = atom() +%%% +%%% @doc Tests are spawned on <code>Node</code> according to <code>TestSpecs</code>. +run_on_node([TS|TestSpecs],AllowUserTerms,Node) when is_list(TS),is_atom(Node) -> + TS1 = + case TS of + [List|_] when is_list(List) -> List; + Spec -> [Spec] + end, + Result = + case catch ct_testspec:collect_tests_from_file(TS1,[Node],AllowUserTerms) of + {error,Reason} -> + {error,Reason}; + TSRec=#testspec{logdir=AllLogDirs, + config=AllCfgFiles, + event_handler=AllEvHs} -> + {Run,Skip} = ct_testspec:prepare_tests(TSRec,Node), + run_all([{Node,Run,Skip}],AllLogDirs,AllCfgFiles,AllEvHs,[],[],TS1) + end, + [{TS,Result} | run_on_node(TestSpecs,AllowUserTerms,Node)]; +run_on_node([],_,_) -> + []; +run_on_node(TS,AllowUserTerms,Node) when is_atom(Node) -> + run_on_node([TS],AllowUserTerms,Node). + +%%%----------------------------------------------------------------- +%%% @spec run_on_node(TestSpecs,Node) -> ok +%%% TestSpecs = string() | [SeparateOrMerged] +%%% SeparateOrMerged = string() | [string()] +%%% Node = atom() +%%% +%%% @equiv run_on_node(TestSpecs,false,Node) +run_on_node(TestSpecs,Node) -> + run_on_node(TestSpecs,false,Node). + + + +run_all([{Node,Run,Skip}|Rest],AllLogDirs,AllCfgFiles,AllEvHs,NodeOpts,LogDirs,Specs) -> + LogDir = + lists:foldl(fun({N,Dir},_Found) when N == Node -> + Dir; + ({_N,_Dir},Found) -> + Found; + (Dir,".") -> + Dir; + (_Dir,Found) -> + Found + end,".",AllLogDirs), + CfgFiles = + lists:foldr(fun({N,F},Fs) when N == Node -> [F|Fs]; + ({_N,_F},Fs) -> Fs; + (F,Fs) -> [F|Fs] + end,[],AllCfgFiles), + EvHs = + lists:foldr(fun({N,H,A},Hs) when N == Node -> [{H,A}|Hs]; + ({_N,_H,_A},Hs) -> Hs; + ({H,A},Hs) -> [{H,A}|Hs] + end,[],AllEvHs), + NO = {Node,[{prepared_tests,{Run,Skip},Specs}, + {logdir,LogDir}, + {config,CfgFiles}, + {event_handler,EvHs}]}, + run_all(Rest,AllLogDirs,AllCfgFiles,AllEvHs,[NO|NodeOpts],[LogDir|LogDirs],Specs); +run_all([],AllLogDirs,_,AllEvHs,NodeOpts,LogDirs,Specs) -> + Handlers = [{H,A} || {Master,H,A} <- AllEvHs, Master == master], + MasterLogDir = case lists:keysearch(master,1,AllLogDirs) of + {value,{_,Dir}} -> Dir; + false -> "." + end, + log(tty,"Master Logdir","~s",[MasterLogDir]), + start_master(lists:reverse(NodeOpts),Handlers,MasterLogDir,LogDirs,Specs), + ok. + + +%%%----------------------------------------------------------------- +%%% @spec abort() -> ok +%%% +%%% @doc Stops all running tests. +abort() -> + call(abort). + +%%%----------------------------------------------------------------- +%%% @spec abort(Nodes) -> ok +%%% Nodes = atom() | [atom()] +%%% +%%% @doc Stops tests on specified nodes. +abort(Nodes) when is_list(Nodes) -> + call({abort,Nodes}); + +abort(Node) when is_atom(Node) -> + abort([Node]). + +%%%----------------------------------------------------------------- +%%% @spec progress() -> [{Node,Status}] +%%% Node = atom() +%%% Status = finished_ok | ongoing | aborted | {error,Reason} +%%% Reason = term() +%%% +%%% @doc Returns test progress. If <code>Status</code> is <code>ongoing</code>, +%%% tests are running on the node and have not yet finished. +progress() -> + call(progress). + + +%%%----------------------------------------------------------------- +%%% MASTER, runs on central controlling node. +%%%----------------------------------------------------------------- +start_master(NodeOptsList) -> + start_master(NodeOptsList,[],".",[],[]). + +start_master(NodeOptsList,EvHandlers,MasterLogDir,LogDirs,Specs) -> + Master = spawn_link(?MODULE,init_master,[self(),NodeOptsList,EvHandlers, + MasterLogDir,LogDirs,Specs]), + receive + {Master,Result} -> Result + end. + +%%% @hidden +init_master(Parent,NodeOptsList,EvHandlers,MasterLogDir,LogDirs,Specs) -> + case whereis(ct_master) of + undefined -> + register(ct_master,self()), + ok; + _Pid -> + io:format("~nWarning: ct_master already running!~n"), + exit(aborted) +% case io:get_line('[y/n]>') of +% "y\n" -> +% ok; +% "n\n" -> +% exit(aborted); +% _ -> +% init_master(NodeOptsList,LogDirs) +% end + end, + + %% start master logger + {MLPid,_} = ct_master_logs:start(MasterLogDir, + [N || {N,_} <- NodeOptsList]), + log(all,"Master Logger process started","~w",[MLPid]), + case Specs of + [] -> ok; + _ -> + SpecsStr = lists:map(fun(Name) -> + Name ++ " " + end,Specs), + ct_master_logs:log("Test Specification file(s)","~s", + [lists:flatten(SpecsStr)]) + end, + + %% start master event manager and add default handler + ct_master_event:start_link(), + ct_master_event:add_handler(), + %% add user handlers for master event manager + Add = fun({H,Args}) -> + log(all,"Adding Event Handler","~p",[H]), + case gen_event:add_handler(?CT_MEVMGR_REF,H,Args) of + ok -> ok; + {'EXIT',Why} -> exit(Why); + Other -> exit({event_handler,Other}) + end + end, + lists:foreach(Add,EvHandlers), + + %% double check event manager is started and registered + case whereis(?CT_MEVMGR) of + undefined -> + exit({?CT_MEVMGR,undefined}); + Pid when is_pid(Pid) -> + ok + end, + init_master1(Parent,NodeOptsList,LogDirs). + +init_master1(Parent,NodeOptsList,LogDirs) -> + {Inaccessible,NodeOptsList1} = ping_nodes(NodeOptsList,[],[]), + case Inaccessible of + [] -> + init_master2(Parent,NodeOptsList,LogDirs); + _ -> + io:format("~nThe following nodes are inaccessible: ~p~n~n", + [Inaccessible]), + io:format("Proceed(p), Rescan(r) or Abort(a)? "), + case io:get_line('[p/r/a]>') of + "p\n" -> + log(html,"Inaccessible Nodes", + "Proceeding without: ~p",[Inaccessible]), + init_master2(Parent,NodeOptsList1,LogDirs); + "r\n" -> + init_master1(Parent,NodeOptsList,LogDirs); + _ -> + log(html,"Aborting Tests","",[]), + ct_master_event:stop(), + ct_master_logs:stop(), + exit(aborted) + end + end. + +init_master2(Parent,NodeOptsList,LogDirs) -> + process_flag(trap_exit,true), + Cookie = erlang:get_cookie(), + log(all,"Cookie","~w",[Cookie]), + log(all,"Starting Tests", + "Tests starting on: ~p",[[N || {N,_} <- NodeOptsList]]), + SpawnAndMon = + fun({Node,Opts}) -> + monitor_node(Node,true), + log(all,"Test Info","Starting test(s) on ~p...",[Node]), + {spawn_link(Node,?MODULE,init_node_ctrl,[self(),Cookie,Opts]),Node} + end, + NodeCtrlPids = lists:map(SpawnAndMon,NodeOptsList), + Result = master_loop(#state{node_ctrl_pids=NodeCtrlPids, + logdirs=LogDirs}), + Parent ! {self(),Result}. + +master_loop(#state{node_ctrl_pids=[], + logdirs=LogDirs, + results=Finished}) -> + Str = + lists:map(fun({Node,Result}) -> + io_lib:format("~-40.40.*s~p\n",[$_,atom_to_list(Node),Result]) + end,lists:reverse(Finished)), + log(all,"TEST RESULTS",Str,[]), + log(all,"Info","Updating log files",[]), + refresh_logs(LogDirs,[]), + + ct_master_event:stop(), + ct_master_logs:stop(), + ok; + +master_loop(State=#state{node_ctrl_pids=NodeCtrlPids, + results=Results, + locks=Locks, + blocked=Blocked}) -> + receive + {'EXIT',Pid,Reason} -> + case get_node(Pid,NodeCtrlPids) of + {Node,NodeCtrlPids1} -> + monitor_node(Node,false), + case Reason of + normal -> + log(all,"Test Info", + "Test(s) on node ~w finished.",[Node]), + master_loop(State#state{node_ctrl_pids=NodeCtrlPids1}); + Bad -> + Error = + case Bad of + What when What=/=killed,is_atom(What) -> + {error,Bad}; + _ -> + Bad + end, + log(all,"Test Info", + "Test on node ~w failed! Reason: ~p",[Node,Error]), + {Locks1,Blocked1} = + update_queue(exit,Node,Locks,Blocked), + master_loop(State#state{node_ctrl_pids=NodeCtrlPids1, + results=[{Node,Error}|Results], + locks=Locks1, + blocked=Blocked1}) + end; + undefined -> + %% ignore (but report) exit from master_logger etc + log(all,"Test Info", + "Warning! Process ~p has terminated. Reason: ~p", + [Pid,Reason]), + master_loop(State) + end; + + {nodedown,Node} -> + case get_pid(Node,NodeCtrlPids) of + {_Pid,NodeCtrlPids1} -> + monitor_node(Node,false), + log(all,"Test Info","No connection to testnode ~w!",[Node]), + {Locks1,Blocked1} = + update_queue(exit,Node,Locks,Blocked), + master_loop(State#state{node_ctrl_pids=NodeCtrlPids1, + results=[{Node,nodedown}|Results], + locks=Locks1, + blocked=Blocked1}); + undefined -> + master_loop(State) + end; + + {Pid,{result,Result}} -> + {Node,_} = get_node(Pid,NodeCtrlPids), + master_loop(State#state{results=[{Node,Result}|Results]}); + + {call,progress,From} -> + reply(master_progress(NodeCtrlPids,Results),From), + master_loop(State); + + {call,abort,From} -> + lists:foreach(fun({Pid,Node}) -> + log(all,"Test Info", + "Aborting tests on ~w",[Node]), + exit(Pid,kill) + end,NodeCtrlPids), + reply(ok,From), + master_loop(State); + + {call,{abort,Nodes},From} -> + lists:foreach(fun(Node) -> + case lists:keysearch(Node,2,NodeCtrlPids) of + {value,{Pid,Node}} -> + log(all,"Test Info", + "Aborting tests on ~w",[Node]), + exit(Pid,kill); + false -> + ok + end + end,Nodes), + reply(ok,From), + master_loop(State); + + {call,#event{name=Name,node=Node,data=Data},From} -> + {Op,Lock} = + case Name of + start_make -> + {take,{make,Data}}; + finished_make -> + {release,{make,Data}}; + start_write_file -> + {take,{write_file,Data}}; + finished_write_file -> + {release,{write_file,Data}} + end, + {Locks1,Blocked1} = + update_queue(Op,Node,From,Lock,Locks,Blocked), + if Op == release -> reply(ok,From); + true -> ok + end, + master_loop(State#state{locks=Locks1, + blocked=Blocked1}); + + {cast,Event} when is_record(Event,event) -> + ct_master_event:notify(Event), + master_loop(State) + + end. + + +update_queue(take,Node,From,Lock={Op,Resource},Locks,Blocked) -> + %% Locks: [{{Operation,Resource},Node},...] + %% Blocked: [{{Operation,Resource},Node,WaitingPid},...] + case lists:keysearch(Lock,1,Locks) of + {value,{_Lock,Owner}} -> % other node has lock + log(html,"Lock Info","Node ~p blocked on ~w by ~w. Resource: ~p", + [Node,Op,Owner,Resource]), + Blocked1 = Blocked ++ [{Lock,Node,From}], + {Locks,Blocked1}; + false -> % go ahead + Locks1 = [{Lock,Node}|Locks], + reply(ok,From), + {Locks1,Blocked} + end; + +update_queue(release,Node,_From,Lock={Op,Resource},Locks,Blocked) -> + Locks1 = lists:delete({Lock,Node},Locks), + case lists:keysearch(Lock,1,Blocked) of + {value,E={Lock,SomeNode,WaitingPid}} -> + Blocked1 = lists:delete(E,Blocked), + log(html,"Lock Info","Node ~p proceeds with ~w. Resource: ~p", + [SomeNode,Op,Resource]), + reply(ok,WaitingPid), % waiting process may start + {Locks1,Blocked1}; + false -> + {Locks1,Blocked} + end. + +update_queue(exit,Node,Locks,Blocked) -> + NodeLocks = lists:foldl(fun({L,N},Ls) when N == Node -> + [L|Ls]; + (_,Ls) -> + Ls + end,[],Locks), + release_locks(Node,NodeLocks,Locks,Blocked). + +release_locks(Node,[Lock|Ls],Locks,Blocked) -> + {Locks1,Blocked1} = update_queue(release,Node,undefined,Lock,Locks,Blocked), + release_locks(Node,Ls,Locks1,Blocked1); +release_locks(_,[],Locks,Blocked) -> + {Locks,Blocked}. + +get_node(Pid,NodeCtrlPids) -> + case lists:keysearch(Pid,1,NodeCtrlPids) of + {value,{Pid,Node}} -> + {Node,lists:keydelete(Pid,1,NodeCtrlPids)}; + false -> + undefined + end. + +get_pid(Node,NodeCtrlPids) -> + case lists:keysearch(Node,2,NodeCtrlPids) of + {value,{Pid,Node}} -> + {Pid,lists:keydelete(Node,2,NodeCtrlPids)}; + false -> + undefined + end. + +ping_nodes([NO={Node,_Opts}|NOs],Inaccessible,NodeOpts) -> + case net_adm:ping(Node) of + pong -> + ping_nodes(NOs,Inaccessible,[NO|NodeOpts]); + _ -> + ping_nodes(NOs,[Node|Inaccessible],NodeOpts) + end; +ping_nodes([],Inaccessible,NodeOpts) -> + {lists:reverse(Inaccessible),lists:reverse(NodeOpts)}. + +master_progress(NodeCtrlPids,Results) -> + Results ++ lists:map(fun({_Pid,Node}) -> + {Node,ongoing} + end,NodeCtrlPids). + +%% refresh those dirs where more than one node has written logs +refresh_logs([D|Dirs],Refreshed) -> + case lists:member(D,Dirs) of + true -> + case lists:keymember(D,1,Refreshed) of + true -> + refresh_logs(Dirs,Refreshed); + false -> + {ok,Cwd} = file:get_cwd(), + case catch ct_run:refresh_logs(D) of + {'EXIT',Reason} -> + file:set_cwd(Cwd), + refresh_logs(Dirs,[{D,{error,Reason}}|Refreshed]); + Result -> + refresh_logs(Dirs,[{D,Result}|Refreshed]) + end + end; + false -> + refresh_logs(Dirs,Refreshed) + end; +refresh_logs([],Refreshed) -> + Str = + lists:map(fun({D,Result}) -> + io_lib:format("Refreshing logs in ~p... ~p",[D,Result]) + end,Refreshed), + log(all,"Info",Str,[]). + +%%%----------------------------------------------------------------- +%%% NODE CONTROLLER, runs and controls tests on a test node. +%%%----------------------------------------------------------------- +%%% @hidden +init_node_ctrl(MasterPid,Cookie,Opts) -> + %% make sure tests proceed even if connection to master is lost + process_flag(trap_exit, true), + MasterNode = node(MasterPid), + group_leader(whereis(user),self()), + io:format("~n********** node_ctrl process ~p started on ~p **********~n", + [self(),node()]), + %% initially this node must have the same cookie as the master node + %% but now we set it explicitly for the connection so that test suites + %% can change the cookie for the node if they wish + case erlang:get_cookie() of + Cookie -> % first time or cookie not changed + erlang:set_cookie(node(MasterPid),Cookie); + _ -> + ok + end, + case whereis(ct_util_server) of + undefined -> ok; + Pid -> exit(Pid,kill) + end, + + %% start a local event manager + ct_event:start_link(), + ct_event:add_handler([{master,MasterPid}]), + + %% log("Running test with options: ~p~n", [Opts]), + Result = case (catch ct:run_test(Opts)) of + ok -> finished_ok; + Other -> Other + end, + + %% stop local event manager + ct_event:stop(), + + case net_adm:ping(MasterNode) of + pong -> + MasterPid ! {self(),{result,Result}}; + pang -> + io:format("Warning! Connection to master node ~p is lost. " + "Can't report result!~n~n", [MasterNode]) + end. + +%%%----------------------------------------------------------------- +%%% Event handling +%%%----------------------------------------------------------------- +%%% @hidden +status(MasterPid,Event=#event{name=start_make}) -> + call(MasterPid,Event); +status(MasterPid,Event=#event{name=finished_make}) -> + call(MasterPid,Event); +status(MasterPid,Event=#event{name=start_write_file}) -> + call(MasterPid,Event); +status(MasterPid,Event=#event{name=finished_write_file}) -> + call(MasterPid,Event); +status(MasterPid,Event) -> + cast(MasterPid,Event). + +%%%----------------------------------------------------------------- +%%% Internal +%%%----------------------------------------------------------------- + +log(To,Heading,Str,Args) -> + if To == all ; To == tty -> + Str1 = ["=== ",Heading," ===\n",io_lib:format(Str,Args),"\n"], + io:format(Str1,[]); + true -> + ok + end, + if To == all ; To == html -> + ct_master_logs:log(Heading,Str,Args); + true -> + ok + end. + + +call(Msg) -> + call(whereis(ct_master),Msg). + +call(undefined,_Msg) -> + {error,not_running}; + +call(Pid,Msg) -> + Ref = erlang:monitor(process,Pid), + Pid ! {call,Msg,self()}, + Return = receive + {Pid,Result} -> + Result; + {'DOWN', Ref, _, _, _} -> + {error,master_died} + end, + erlang:demonitor(Ref), + Return. + +reply(Result,To) -> + To ! {self(),Result}, + ok. + +%cast(Msg) -> +% cast(whereis(ct_master),Msg). + +cast(undefined,_Msg) -> + {error,not_running}; + +cast(Pid,Msg) -> + Pid ! {cast,Msg}, + ok. diff --git a/lib/common_test/src/ct_master_event.erl b/lib/common_test/src/ct_master_event.erl new file mode 100644 index 0000000000..a70baefaaf --- /dev/null +++ b/lib/common_test/src/ct_master_event.erl @@ -0,0 +1,179 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework Event Handler +%%% +%%% <p>This module implements an event handler that the CT Master +%%% uses to handle status and progress notifications sent to the +%%% master node during test runs. This module may be used as a +%%% template for other event handlers that can be plugged in to +%%% handle logging and reporting on the master node.</p> +-module(ct_master_event). + +-behaviour(gen_event). + +%% API +-export([start_link/0, add_handler/0, add_handler/1, stop/0]). +-export([notify/1, sync_notify/1]). + +%% gen_event callbacks +-export([init/1, handle_event/2, handle_call/2, + handle_info/2, terminate/2, code_change/3]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). + + +-record(state, {}). + +%%==================================================================== +%% gen_event callbacks +%%==================================================================== +%%-------------------------------------------------------------------- +%% Function: start_link() -> {ok,Pid} | {error,Error} +%% Description: Creates an event manager. +%%-------------------------------------------------------------------- +start_link() -> + gen_event:start_link({local,?CT_MEVMGR}). + +%%-------------------------------------------------------------------- +%% Function: add_handler() -> ok | {'EXIT',Reason} | term() +%% Description: Adds an event handler +%%-------------------------------------------------------------------- +add_handler() -> + gen_event:add_handler(?CT_MEVMGR_REF,?MODULE,[]). +add_handler(Args) -> + gen_event:add_handler(?CT_MEVMGR_REF,?MODULE,Args). + +%%-------------------------------------------------------------------- +%% Function: stop() -> ok +%% Description: Stops the event manager +%%-------------------------------------------------------------------- +stop() -> + flush(), + gen_event:stop(?CT_MEVMGR_REF). + +flush() -> + case gen_event:call(?CT_MEVMGR_REF,?MODULE,flush) of + flushing -> + timer:sleep(1), + flush(); + done -> + ok + end. + +%%-------------------------------------------------------------------- +%% Function: notify(Event) -> ok +%% Description: Asynchronous notification to event manager. +%%-------------------------------------------------------------------- +notify(Event) -> + gen_event:notify(?CT_MEVMGR_REF,Event). + +%%-------------------------------------------------------------------- +%% Function: sync_notify(Event) -> ok +%% Description: Synchronous notification to event manager. +%%-------------------------------------------------------------------- +sync_notify(Event) -> + gen_event:sync_notify(?CT_MEVMGR_REF,Event). + +%%==================================================================== +%% gen_event callbacks +%%==================================================================== +%%-------------------------------------------------------------------- +%% Function: init(Args) -> {ok, State} +%% Description: Whenever a new event handler is added to an event manager, +%% this function is called to initialize the event handler. +%%-------------------------------------------------------------------- +init(_) -> + ct_master_logs:log("CT Master Event Handler started","",[]), + {ok,#state{}}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_event(Event, State) -> {ok, State} | +%% {swap_handler, Args1, State1, Mod2, Args2} | +%% remove_handler +%% Description:Whenever an event manager receives an event sent using +%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for +%% each installed event handler to handle the event. +%%-------------------------------------------------------------------- +handle_event(#event{name=start_logging,node=Node,data=RunDir},State) -> + ct_master_logs:log("CT Master Event Handler","Got ~s from ~p",[RunDir,Node]), + ct_master_logs:nodedir(Node,RunDir), + {ok,State}; + +handle_event(#event{name=Name,node=Node,data=Data},State) -> + print("~n=== ~w ===~n", [?MODULE]), + print("~p on ~p: ~p~n", [Name,Node,Data]), + {ok,State}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_call(Request, State) -> {ok, Reply, State} | +%% {swap_handler, Reply, Args1, State1, +%% Mod2, Args2} | +%% {remove_handler, Reply} +%% Description: Whenever an event manager receives a request sent using +%% gen_event:call/3,4, this function is called for the specified event +%% handler to handle the request. +%%-------------------------------------------------------------------- +handle_call(flush,State) -> + case process_info(self(),message_queue_len) of + {message_queue_len,0} -> + {ok,done,State}; + _ -> + {ok,flushing,State} + end. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_info(Info, State) -> {ok, State} | +%% {swap_handler, Args1, State1, Mod2, Args2} | +%% remove_handler +%% Description: This function is called for each installed event handler when +%% an event manager receives any other message than an event or a synchronous +%% request (or a system message). +%%-------------------------------------------------------------------- +handle_info(_Info,State) -> + {ok,State}. + +%%-------------------------------------------------------------------- +%% Function: terminate(Reason, State) -> void() +%% Description:Whenever an event handler is deleted from an event manager, +%% this function is called. It should be the opposite of Module:init/1 and +%% do any necessary cleaning up. +%%-------------------------------------------------------------------- +terminate(_Reason,_State) -> + ct_master_logs:log("CT Master Event Handler stopping","",[]), + ok. + +%%-------------------------------------------------------------------- +%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState} +%% Description: Convert process state when code is changed +%%-------------------------------------------------------------------- +code_change(_OldVsn,State,_Extra) -> + {ok,State}. + +%%-------------------------------------------------------------------- +%%% Internal functions +%%-------------------------------------------------------------------- + +print(_Str,_Args) -> +% io:format(_Str,_Args), + ok. diff --git a/lib/common_test/src/ct_master_logs.erl b/lib/common_test/src/ct_master_logs.erl new file mode 100644 index 0000000000..63f60b1182 --- /dev/null +++ b/lib/common_test/src/ct_master_logs.erl @@ -0,0 +1,454 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Logging functionality for Common Test Master. +%%% +%%% <p>This module implements a logger for the master +%%% node.</p> +-module(ct_master_logs). + +-export([start/2, make_all_runs_index/0, log/3, nodedir/2, stop/0]). + +-record(state, {log_fd, start_time, logdir, rundir, + nodedir_ix_fd, nodes, nodedirs=[]}). + +-define(ct_master_log_name, "ct_master_log.html"). +-define(all_runs_name, "master_runs.html"). +-define(nodedir_index_name, "index.html"). +-define(details_file_name,"details.info"). +-define(table_color,"lightblue"). + +%%%-------------------------------------------------------------------- +%%% API +%%%-------------------------------------------------------------------- + +start(LogDir,Nodes) -> + Self = self(), + Pid = spawn_link(fun() -> init(Self,LogDir,Nodes) end), + MRef = erlang:monitor(process,Pid), + receive + {started,Pid,Result} -> + erlang:demonitor(MRef), + {Pid,Result}; + {'DOWN',MRef,process,_,Reason} -> + exit({could_not_start_process,?MODULE,Reason}) + end. + +log(Heading,Format,Args) -> + cast({log,self(),[{int_header(),[log_timestamp(now()),Heading]}, + {Format,Args}, + {int_footer(),[]}]}), + ok. + +make_all_runs_index() -> + call(make_all_runs_index). + +nodedir(Node,RunDir) -> + call({nodedir,Node,RunDir}). + +stop() -> + case whereis(?MODULE) of + Pid when is_pid(Pid) -> + MRef = erlang:monitor(process,Pid), + ?MODULE ! stop, + receive + {'DOWN',MRef,process,_,_} -> + ok + end; + undefined -> + ok + end, + ok. + +%%%-------------------------------------------------------------------- +%%% Logger process +%%%-------------------------------------------------------------------- + +init(Parent,LogDir,Nodes) -> + register(?MODULE,self()), + Time = calendar:local_time(), + RunDir = make_dirname(Time), + RunDirAbs = filename:join(LogDir,RunDir), + file:make_dir(RunDirAbs), + write_details_file(RunDirAbs,{node(),Nodes}), + make_all_runs_index(LogDir), + CtLogFd = open_ct_master_log(RunDirAbs), + NodeStr = + lists:flatten(lists:map(fun(N) -> + atom_to_list(N) ++ " " + end,Nodes)), + + io:format(CtLogFd,int_header(),[log_timestamp(now()),"Test Nodes\n"]), + io:format(CtLogFd,"~s\n",[NodeStr]), + io:format(CtLogFd,int_footer()++"\n",[]), + + NodeDirIxFd = open_nodedir_index(RunDirAbs,Time), + Parent ! {started,self(),{Time,RunDirAbs}}, + loop(#state{log_fd=CtLogFd, + start_time=Time, + logdir=LogDir, + rundir=RunDirAbs, + nodedir_ix_fd=NodeDirIxFd, + nodes=Nodes, + nodedirs=lists:map(fun(N) -> + {N,""} + end,Nodes)}). + +loop(State) -> + receive + {log,_From,List} -> + Fd = State#state.log_fd, + Fun = + fun({Str,Args}) -> + case catch io:format(Fd,Str++"\n",Args) of + {'EXIT',Reason} -> + io:format(Fd, + "Logging fails! Str: ~p, Args: ~p~n", + [Str,Args]), + exit({logging_failed,Reason}), + ok; + _ -> + ok + end + end, + lists:foreach(Fun,List), + loop(State); + {make_all_runs_index,From} -> + make_all_runs_index(State#state.logdir), + return(From,State#state.logdir), + loop(State); + {{nodedir,Node,RunDir},From} -> + print_nodedir(Node,RunDir,State#state.nodedir_ix_fd), + return(From,ok), + loop(State); + stop -> + make_all_runs_index(State#state.logdir), + io:format(State#state.log_fd, + int_header()++int_footer(), + [log_timestamp(now()),"Finished!"]), + close_ct_master_log(State#state.log_fd), + close_nodedir_index(State#state.nodedir_ix_fd), + ok + end. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%% Master Log functions %%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%% +open_ct_master_log(Dir) -> + FullName = filename:join(Dir,?ct_master_log_name), + {ok,Fd} = file:open(FullName,[write]), + io:format(Fd,header("Common Test Master Log"),[]), + %% maybe add config info here later + io:format(Fd, config_table([]), []), + io:format(Fd, + "<style>\n" + "div.ct_internal { background:lightgrey; color:black }\n" + "div.default { background:lightgreen; color:black }\n" + "</style>\n", + []), + io:format(Fd, + "<br><h2>Progress Log</h2>\n" + "<pre>\n",[]), + Fd. + +close_ct_master_log(Fd) -> + io:format(Fd,"</pre>",[]), + io:format(Fd,footer(),[]), + file:close(Fd). + +config_table(Vars) -> + [config_table_header()|config_table1(Vars)]. + +config_table_header() -> + ["<h2>Configuration</h2>\n", + "<table border=\"3\" cellpadding=\"5\" bgcolor=\"",?table_color, + "\"\n", + "<tr><th>Key</th><th>Value</th></tr>\n"]. + +%% +%% keep for possible later use +%% +%%config_table1([{Key,Value}|Vars]) -> +%% ["<tr><td>", atom_to_list(Key), "</td>\n", +%% "<td><pre>",io_lib:format("~p",[Value]),"</pre></td></tr>\n" | +%% config_table1(Vars)]; + +config_table1([]) -> + ["</table>\n"]. + +int_header() -> + "<div class=\"ct_internal\"><b>*** CT MASTER ~s *** ~s</b>". +int_footer() -> + "</div>". + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%% NodeDir Index functions %%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +open_nodedir_index(Dir,StartTime) -> + FullName = filename:join(Dir,?nodedir_index_name), + {ok,Fd} = file:open(FullName,[write]), + io:format(Fd,nodedir_index_header(StartTime),[]), + Fd. + +print_nodedir(Node,RunDir,Fd) -> + Index = filename:join(RunDir,"index.html"), + io:format(Fd, + ["<TR>\n" + "<TD ALIGN=center>",atom_to_list(Node),"</TD>\n", + "<TD ALIGN=left><A HREF=\"",Index,"\">",Index,"</A></TD>\n", + "</TR>\n"],[]), + ok. + +close_nodedir_index(Fd) -> + io:format(Fd,index_footer(),[]), + file:close(Fd). + +nodedir_index_header(StartTime) -> + [header("Log Files " ++ format_time(StartTime)) | + ["<CENTER>\n", + "<P><A HREF=\"",?ct_master_log_name,"\">Common Test Master Log</A></P>", + "<TABLE border=\"3\" cellpadding=\"5\" ", + "BGCOLOR=\"",?table_color,"\">\n", + "<th><B>Node</B></th>\n", + "<th><B>Log</B></th>\n", + "\n"]]. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%% All Run Index functions %%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +make_all_runs_index(LogDir) -> + FullName = filename:join(LogDir,?all_runs_name), + Match = filename:join(LogDir,logdir_prefix()++"*.*"), + Dirs = filelib:wildcard(Match), + DirsSorted = (catch sort_all_runs(Dirs)), + Header = all_runs_header(), + Index = [runentry(Dir) || Dir <- DirsSorted], + Result = file:write_file(FullName,Header++Index++index_footer()), + Result. + +sort_all_runs(Dirs) -> + %% sort on time string, always last and on the format: + %% "YYYY-MM-DD_HH.MM.SS" + KeyList = + lists:map(fun(Dir) -> + case lists:reverse(string:tokens(Dir,[$.,$_])) of + [SS,MM,HH,Date|_] -> + {{Date,HH,MM,SS},Dir}; + _Other -> + throw(Dirs) + end + end,Dirs), + lists:reverse(lists:map(fun({_,Dir}) -> + Dir + end,lists:keysort(1,KeyList))). + +runentry(Dir) -> + {MasterStr,NodesStr} = + case read_details_file(Dir) of + {Master,Nodes} when is_list(Nodes) -> + [_,Host] = string:tokens(atom_to_list(Master),"@"), + NodesList = + lists:reverse(lists:map(fun(N) -> + atom_to_list(N) ++ ", " + end,Nodes)), + case NodesList of + [N|NListR] -> + N1 = string:sub_string(N,1,length(N)-2), + {Host,lists:flatten(lists:reverse([N1|NListR]))}; + [] -> + {Host,""} + end; + _Error -> + {"unknown",""} + end, + Index = filename:join(Dir,?nodedir_index_name), + ["<TR>\n" + "<TD ALIGN=center><A HREF=\"",Index,"\">",timestamp(Dir),"</A></TD>\n", + "<TD ALIGN=center>",MasterStr,"</TD>\n", + "<TD ALIGN=center>",NodesStr,"</TD>\n", + "</TR>\n"]. + +all_runs_header() -> + [header("Master Test Runs") | + ["<CENTER>\n", + "<TABLE border=\"3\" cellpadding=\"5\" " + "BGCOLOR=\"",?table_color,"\">\n" + "<th><B>History</B></th>\n" + "<th><B>Master Host</B></th>\n" + "<th><B>Test Nodes</B></th>\n" + "\n"]]. + +timestamp(Dir) -> + [S,Min,H,D,M,Y|_] = lists:reverse(string:tokens(Dir,".-_")), + [S1,Min1,H1,D1,M1,Y1] = [list_to_integer(N) || N <- [S,Min,H,D,M,Y]], + format_time({{Y1,M1,D1},{H1,Min1,S1}}). + +write_details_file(Dir,Details) -> + FullName = filename:join(Dir,?details_file_name), + force_write_file(FullName,term_to_binary(Details)). + +read_details_file(Dir) -> + FullName = filename:join(Dir,?details_file_name), + case file:read_file(FullName) of + {ok,Bin} -> + binary_to_term(Bin); + Error -> + Error + end. + +%%%-------------------------------------------------------------------- +%%% Internal functions +%%%-------------------------------------------------------------------- + +header(Title) -> + ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n" + "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n" + "<HTML>\n", + "<HEAD>\n", + + "<TITLE>" ++ Title ++ "</TITLE>\n", + "<META HTTP-EQUIV=\"CACHE-CONTROL\" CONTENT=\"NO-CACHE\">\n", + + "</HEAD>\n", + + body_tag(), + + "<!-- ---- DOCUMENT TITLE ---- -->\n", + + "<CENTER>\n", + "<H1>" ++ Title ++ "</H1>\n", + "</CENTER>\n", + + "<!-- ---- CONTENT ---- -->\n"]. + +index_footer() -> + ["</TABLE>\n" + "</CENTER>\n" | footer()]. + +footer() -> + ["<P><CENTER>\n" + "<HR>\n" + "<P><FONT SIZE=-1>\n" + "Copyright © ", year(), + " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n" + "Updated: <!date>", current_time(), "<!/date><BR>\n" + "</FONT>\n" + "</CENTER>\n" + "</body>\n"]. + +body_tag() -> + "<body bgcolor=\"#FFFFFF\" text=\"#000000\" link=\"#0000FF\"" + "vlink=\"#800080\" alink=\"#FF0000\">\n". + +current_time() -> + format_time(calendar:local_time()). + +format_time({{Y, Mon, D}, {H, Min, S}}) -> + Weekday = weekday(calendar:day_of_the_week(Y, Mon, D)), + lists:flatten(io_lib:format("~s ~s ~p ~w ~2.2.0w:~2.2.0w:~2.2.0w", + [Weekday, month(Mon), D, Y, H, Min, S])). + +weekday(1) -> "Mon"; +weekday(2) -> "Tue"; +weekday(3) -> "Wed"; +weekday(4) -> "Thu"; +weekday(5) -> "Fri"; +weekday(6) -> "Sat"; +weekday(7) -> "Sun". + +month(1) -> "Jan"; +month(2) -> "Feb"; +month(3) -> "Mar"; +month(4) -> "Apr"; +month(5) -> "May"; +month(6) -> "Jun"; +month(7) -> "Jul"; +month(8) -> "Aug"; +month(9) -> "Sep"; +month(10) -> "Oct"; +month(11) -> "Nov"; +month(12) -> "Dec". + +year() -> + {Y, _, _} = date(), + integer_to_list(Y). + + +make_dirname({{YY,MM,DD},{H,M,S}}) -> + io_lib:format(logdir_prefix()++".~w-~2.2.0w-~2.2.0w_~2.2.0w.~2.2.0w.~2.2.0w", + [YY,MM,DD,H,M,S]). + +logdir_prefix() -> + "ct_master_run". + +log_timestamp(Now) -> + put(log_timestamp,Now), + {_,{H,M,S}} = calendar:now_to_local_time(Now), + lists:flatten(io_lib:format("~2.2.0w:~2.2.0w:~2.2.0w", + [H,M,S])). + +force_write_file(Name,Contents) -> + force_delete(Name), + file:write_file(Name,Contents). + +force_delete(Name) -> + case file:delete(Name) of + {error,eacces} -> + force_rename(Name,Name++".old.",0); + Other -> + Other + end. + +force_rename(From,To,Number) -> + Dest = [To|integer_to_list(Number)], + case file:read_file_info(Dest) of + {ok,_} -> + force_rename(From,To,Number+1); + {error,_} -> + file:rename(From,Dest) + end. + +call(Msg) -> + case whereis(?MODULE) of + undefined -> + {error,does_not_exist}; + Pid -> + MRef = erlang:monitor(process,Pid), + Ref = make_ref(), + ?MODULE ! {Msg,{self(),Ref}}, + receive + {Ref, Result} -> + erlang:demonitor(MRef), + Result; + {'DOWN',MRef,process,_,Reason} -> + {error,{process_down,?MODULE,Reason}} + end + end. + +return({To,Ref},Result) -> + To ! {Ref, Result}. + +cast(Msg) -> + case whereis(?MODULE) of + undefined -> + {error,does_not_exist}; + _Pid -> + ?MODULE ! Msg + end. diff --git a/lib/common_test/src/ct_master_status.erl b/lib/common_test/src/ct_master_status.erl new file mode 100644 index 0000000000..76060fb7bb --- /dev/null +++ b/lib/common_test/src/ct_master_status.erl @@ -0,0 +1,124 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Logging functionality for Common Test Master. +%%% +%%% <p>This module keeps a list of <code>{Node,Status}</code> +%%% tuples. It is possible to anytime during a test run get +%%% a snapshot of the test status. The module is an event +%%% handler for the master event manager.</p> +-module(ct_master_status). + +-behaviour(gen_event). + +-export([]). + +%% gen_event callbacks +-export([init/1, handle_event/2, handle_call/2, + handle_info/2, terminate/2, code_change/3]). + +-include("ct_event.hrl"). + +-record(state, {status=[]}). + +%%==================================================================== +%% gen_event callbacks +%%==================================================================== +%%-------------------------------------------------------------------- +%% Function: init(Args) -> {ok, State} +%% Description: Whenever a new event handler is added to an event manager, +%% this function is called to initialize the event handler. +%%-------------------------------------------------------------------- +init(_) -> + {ok,#state{}}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_event(Event, State) -> {ok, State} | +%% {swap_handler, Args1, State1, Mod2, Args2} | +%% remove_handler +%% Description:Whenever an event manager receives an event sent using +%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for +%% each installed event handler to handle the event. +%%-------------------------------------------------------------------- + +%%============================== EVENTS ============================== +%% +%% Events documented in ct_event, plus: +%% +%% Name = pending_make +%% Data = {Node,Dir} +%% +%% Name = go_ahead_make +%% Data = {Node,Dir} +%% +handle_event(#event{name=Name,node=Node,data=Data},State) -> + print("~n=== ~w ===~n", [?MODULE]), + print("~p on ~p: ~p~n", [Name,Node,Data]), + {ok,State}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_call(Request, State) -> {ok, Reply, State} | +%% {swap_handler, Reply, Args1, State1, +%% Mod2, Args2} | +%% {remove_handler, Reply} +%% Description: Whenever an event manager receives a request sent using +%% gen_event:call/3,4, this function is called for the specified event +%% handler to handle the request. +%%-------------------------------------------------------------------- +handle_call(_Req, State) -> + Reply = ok, + {ok, Reply, State}. + +%%-------------------------------------------------------------------- +%% Function: +%% handle_info(Info, State) -> {ok, State} | +%% {swap_handler, Args1, State1, Mod2, Args2} | +%% remove_handler +%% Description: This function is called for each installed event handler when +%% an event manager receives any other message than an event or a synchronous +%% request (or a system message). +%%-------------------------------------------------------------------- +handle_info(_Info, State) -> + {ok, State}. + +%%-------------------------------------------------------------------- +%% Function: terminate(Reason, State) -> void() +%% Description:Whenever an event handler is deleted from an event manager, +%% this function is called. It should be the opposite of Module:init/1 and +%% do any necessary cleaning up. +%%-------------------------------------------------------------------- +terminate(_Reason, _State) -> + ok. + +%%-------------------------------------------------------------------- +%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState} +%% Description: Convert process state when code is changed +%%-------------------------------------------------------------------- +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +%%-------------------------------------------------------------------- +%%% Internal functions +%%-------------------------------------------------------------------- + +print(_Str,_Args) -> + ok. + diff --git a/lib/common_test/src/ct_repeat.erl b/lib/common_test/src/ct_repeat.erl new file mode 100644 index 0000000000..7ac6e045d7 --- /dev/null +++ b/lib/common_test/src/ct_repeat.erl @@ -0,0 +1,263 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2007-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework module that handles repeated test runs +%%% +%%% <p>This module exports functions for repeating tests. The following +%%% script flags (or equivalent ct:run_test/1 options) are supported: +%%% -until <StopTime>, StopTime = YYMoMoDDHHMMSS | HHMMSS +%%% -duration <DurTime>, DurTime = HHMMSS +%%% -force_stop +%%% -repeat <N>, N = integer()</p> + +-module(ct_repeat). + +%% Script interface +-export([loop_test/2]). +-export([log_loop_info/1]). + +%%---------------------------------------------------------- +%% Flags: +%%---------------------------------------------------------- + +loop_test(If,Args) when is_list(Args) -> + {ok,Cwd} = file:get_cwd(), + case get_loop_info(Args) of + no_loop -> + false; + {error,E} -> + io:format("Common Test error: ~p\n\n",[E]), + file:set_cwd(Cwd), + E; + {repeat,N} -> + io:format("\nCommon Test: Will repeat tests ~w times.\n\n",[N]), + Args1 = [{loop_info,[{repeat,1,N}]} | Args], + loop(If,repeat,0,N,undefined,Args1,undefined), + file:set_cwd(Cwd); + {stop_time,StopTime} -> + case remaining_time(StopTime) of + 0 -> + io:format("\nCommon Test: No time left to run tests.\n\n",[]), + ok; + Secs -> + io:format("\nCommon Test: Will repeat tests for ~s.\n\n", + [ts(Secs)]), + TPid = + case lists:keymember(force_stop,1,Args) of + true -> + CtrlPid = self(), + spawn(fun() -> stop_after(CtrlPid,Secs) end); + false -> + undefined + end, + Args1 = [{loop_info,[{stop_time,Secs,StopTime,1}]} | Args], + loop(If,stop_time,0,Secs,StopTime,Args1,TPid) + end, + file:set_cwd(Cwd) + end. + +loop(_,repeat,N,N,_,_Args,_) -> + ok; + +loop(If,Type,N,Data0,Data1,Args,TPid) -> + Pid = spawn_tester(If,self(),Args), + receive + {'EXIT',Pid,Reason} -> + io:format("Test run crashed! This could be an internal error " + "- please report!\n\n" + "~p\n\n",[Reason]), + cancel(TPid), + {error,Reason}; + {Pid,{error,Reason}} -> + io:format("\nTest run failed!\nReason: ~p\n\n",[Reason]), + cancel(TPid), + {error,Reason}; + {Pid,Result} -> + if Type == repeat -> + io:format("\nTest run ~w(~w) complete.\n\n",[N+1,Data0]), + lists:keydelete(loop_info,1,Args), + Args1 = [{loop_info,[{repeat,N+2,Data0}]} | Args], + loop(If,repeat,N+1,Data0,Data1,Args1,TPid); + Type == stop_time -> + case remaining_time(Data1) of + 0 -> + io:format("\nTest time (~s) has run out.\n\n",[ts(Data0)]), + cancel(TPid), + Result; + Secs -> + io:format("\n~s of test time remaining, " + "starting run #~w...\n\n",[ts(Secs),N+2]), + lists:keydelete(loop_info,1,Args), + ST = {stop_time,Data0,Data1,N+2}, + Args1 = [{loop_info,[ST]} | Args], + loop(If,stop_time,N+1,Data0,Data1,Args1,TPid) + end + end + end. + +spawn_tester(script,Ctrl,Args) -> + spawn_link(fun() -> ct_run:script_start1(Ctrl,Args) end); + +spawn_tester(func,Ctrl,Opts) -> + Tester = fun() -> + case catch ct_run:run_test1(Opts) of + {'EXIT',Reason} -> + exit(Reason); + Result -> + Ctrl ! {self(),Result} + end + end, + spawn_link(Tester). + +remaining_time(StopTime) -> + Now = calendar:datetime_to_gregorian_seconds(calendar:local_time()), + Diff = StopTime - Now, + if Diff > 0 -> + Diff; + true -> + 0 + end. + +get_loop_info(Args) when is_list(Args) -> + case lists:keysearch(until,1,Args) of + {value,{until,Time}} -> + Time1 = delistify(Time), + case catch get_stop_time(until,Time1) of + {'EXIT',_} -> + {error,{bad_time_format,Time1}}; + Stop -> + {stop_time,Stop} + end; + false -> + case lists:keysearch(duration,1,Args) of + {value,{duration,Time}} -> + Time1 = delistify(Time), + case catch get_stop_time(duration,Time1) of + {'EXIT',_} -> + {error,{bad_time_format,Time1}}; + Stop -> + {stop_time,Stop} + end; + false -> + case lists:keysearch(repeat,1,Args) of + {value,{repeat,R}} -> + case R of + N when is_integer(N), N>0 -> + {repeat,N}; + [Str] -> + case catch list_to_integer(Str) of + N when is_integer(N), N>0 -> + {repeat,N}; + _ -> + {error,{invalid_repeat_value,Str}} + end; + _ -> + {error,{invalid_repeat_value,R}} + end; + false -> + no_loop + end + end + end. + +get_stop_time(until,[Y1,Y2,Mo1,Mo2,D1,D2,H1,H2,Mi1,Mi2,S1,S2]) -> + Date = + case [Mo1,Mo2] of + "00" -> + date(); + _ -> + Y = list_to_integer([Y1,Y2]), + Mo = list_to_integer([Mo1,Mo2]), + D = list_to_integer([D1,D2]), + {YNow,_,_} = date(), + Dec = trunc(YNow/100), + Year = + if Y < (YNow-Dec*100) -> (Dec+1)*100 + Y; + true -> Dec*100 + Y + end, + {Year,Mo,D} + end, + Time = {list_to_integer([H1,H2]), + list_to_integer([Mi1,Mi2]), + list_to_integer([S1,S2])}, + calendar:datetime_to_gregorian_seconds({Date,Time}); + +get_stop_time(until,Time) -> + get_stop_time(until,"000000"++Time); + +get_stop_time(duration,[H1,H2,Mi1,Mi2,S1,S2]) -> + Secs = + list_to_integer([H1,H2]) * 3600 + + list_to_integer([Mi1,Mi2]) * 60 + + list_to_integer([S1,S2]), + calendar:datetime_to_gregorian_seconds(calendar:local_time()) + Secs. + +cancel(Pid) -> + catch exit(Pid,kill). + +%% After Secs, abort will make the test_server finish the current +%% job, then empty the job queue and stop. +stop_after(_CtrlPid,Secs) -> + timer:sleep(Secs*1000), + test_server_ctrl:abort(). + +%% Callback from ct_run to print loop info to system log. +log_loop_info(Args) -> + case lists:keysearch(loop_info,1,Args) of + false -> + ok; + {value,{_,[{repeat,C,N}]}} -> + ct_logs:log("Test loop info","Test run ~w of ~w",[C,N]); + {value,{_,[{stop_time,Secs0,StopTime,N}]}} -> + LogStr1 = + case lists:keysearch(duration,1,Args) of + {value,{_,Dur}} -> + io_lib:format("Specified test duration: ~s (~w secs)\n", + [delistify(Dur),Secs0]); + _ -> + case lists:keysearch(until,1,Args) of + {value,{_,Until}} -> + io_lib:format("Specified end time: ~s (duration ~w secs)\n", + [delistify(Until),Secs0]); + _ -> + ok + end + end, + LogStr2 = io_lib:format("Test run #~w\n", [N]), + Secs = remaining_time(StopTime), + LogStr3 = + io_lib:format("Test time remaining: ~w secs (~w%)\n", + [Secs,trunc((Secs/Secs0)*100)]), + LogStr4 = + case lists:keymember(force_stop,1,Args) of + true -> + io_lib:format("force_stop is enabled",[]); + _ -> + "" + end, + ct_logs:log("Test loop info",LogStr1++LogStr2++LogStr3++LogStr4,[]) + end. + +ts(Secs) -> + integer_to_list(Secs) ++ " secs". + +delistify([X]) -> + X; +delistify(X) -> + X. diff --git a/lib/common_test/src/ct_rpc.erl b/lib/common_test/src/ct_rpc.erl new file mode 100644 index 0000000000..03d95d1408 --- /dev/null +++ b/lib/common_test/src/ct_rpc.erl @@ -0,0 +1,204 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test specific layer on Erlang/OTP rpc. + +-module(ct_rpc). + +%%% API +-export([app_node/2, app_node/3, app_node/4, + call/4, call/5, call/6, cast/4, cast/5]). + +%%%========================================================================= +%%% API +%%%========================================================================= +%%% @spec app_node(App, Candidates) -> NodeName +%%% +%%% App = atom() +%%% Candidates = [NodeName] +%%% NodeName = atom() +%%% +%%% @doc From a set of candidate nodes determines which of them is +%%% running the application App. If none of the candidate nodes +%%% is running the application the function will make the test case +%%% calling this function fail. This function is the same as calling +%%% <code>app_node(App, Candidates, true)</code>. +%%% +app_node(App, Candidates) -> + app_node(App, Candidates, true, []). + +%%% @spec app_node(App, Candidates, FailOnBadRPC) -> NodeName +%%% +%%% App = atom() +%%% Candidates = [NodeName] +%%% NodeName = atom() +%%% FailOnBadRPC = true | false +%%% +%%% @doc Same as <code>app_node/2</code> only the <code>FailOnBadRPC</code> +%%% argument will determine if the search for a candidate node should +%%% stop or not if <code>badrpc</code> is received at some point. +%%% +app_node(App, Candidates, FailOnBadRPC) -> + app_node(App, Candidates, FailOnBadRPC, []). + +%%% @spec app_node(App, Candidates, FailOnBadRPC, Cookie) -> NodeName +%%% +%%% App = atom() +%%% Candidates = [NodeName] +%%% NodeName = atom() +%%% FailOnBadRPC = true | false +%%% Cookie = atom() +%%% +%%% @doc Same as <code>app_node/2</code> only the <code>FailOnBadRPC</code> +%%% argument will determine if the search for a candidate node should +%%% stop or not if <code>badrpc</code> is received at some point. +%%% The cookie on the client node will be set to <code>Cookie</code> +%%% for this rpc operation (use to match the server node cookie). +%%% +app_node(App, [], _, _) -> + ct:fail({application_not_running, App}); + +%% Variable _Candidates is a workaround for the strange edoc behavior +%% of creating the spec: app_node(App, Nodes::Candidates) -> NodeName +%% if it does not exist. +app_node(App, _Candidates = [CandidateNode | Nodes], FailOnBadRPC, Cookie) -> + Cookie0 = set_the_cookie(Cookie), + Result = rpc:call(CandidateNode, application, which_applications, []), + set_the_cookie(Cookie0), + case Result of + {badrpc,Reason} when FailOnBadRPC == true -> + ct:fail({Reason,CandidateNode}); + {badrpc,_} when FailOnBadRPC == false -> + app_node(App, Nodes, FailOnBadRPC); + Apps -> + case lists:keysearch(App, 1, Apps) of + {value, _} -> + CandidateNode; + _ -> + app_node(App, Nodes, FailOnBadRPC) + end + end. + +%%% @spec call(Node, Module, Function, Args) -> term() | {badrpc, Reason} +%%% +%%% @doc Same as call(Node, Module, Function, Args, infinity) +%%% +call(Node, Module, Function, Args) -> + call(Node, Module, Function, Args, infinity, []). + +%%% @spec call(Node, Module, Function, Args, TimeOut) -> +%%% term() | {badrpc, Reason} +%%% Node = NodeName | {Fun, FunArgs} +%%% Fun = fun() +%%% FunArgs = term() +%%% NodeName = atom() +%%% Module = atom() +%%% Function = atom() +%%% Args = [term()] +%%% Reason = timeout | term() +%%% +%%% @doc Evaluates apply(Module, Function, Args) on the node Node. +%%% Returns whatever Function returns or {badrpc, Reason} if the +%%% remote procedure call fails. If Node is {Fun, FunArgs} applying +%%% Fun to FunArgs should return a node name. +call(Node, Module, Function, Args, TimeOut) -> + call(Node, Module, Function, Args, TimeOut, []). + +%%% @spec call(Node, Module, Function, Args, TimeOut, Cookie) -> +%%% term() | {badrpc, Reason} +%%% Node = NodeName | {Fun, FunArgs} +%%% Fun = fun() +%%% FunArgs = term() +%%% NodeName = atom() +%%% Module = atom() +%%% Function = atom() +%%% Args = [term()] +%%% Reason = timeout | term() +%%% Cookie = atom() +%%% +%%% @doc Evaluates apply(Module, Function, Args) on the node Node. +%%% Returns whatever Function returns or {badrpc, Reason} if the +%%% remote procedure call fails. If Node is {Fun, FunArgs} applying +%%% Fun to FunArgs should return a node name. +%%% The cookie on the client node will be set to <code>Cookie</code> +%%% for this rpc operation (use to match the server node cookie). +call({Fun, FunArgs}, Module, Function, Args, TimeOut, Cookie) -> + Node = Fun(FunArgs), + call(Node, Module, Function, Args, TimeOut, Cookie); +call(Node, Module, Function, Args, TimeOut, Cookie) when is_atom(Node) -> + Cookie0 = set_the_cookie(Cookie), + Result = rpc:call(Node, Module, Function, Args, TimeOut), + set_the_cookie(Cookie0), + Result. + +%%% @spec cast(Node, Module, Function, Args) -> ok +%%% Node = NodeName | {Fun, FunArgs} +%%% Fun = fun() +%%% FunArgs = term() +%%% NodeName = atom() +%%% Module = atom() +%%% Function = atom() +%%% Args = [term()] +%%% Reason = timeout | term() +%%% +%%% @doc Evaluates apply(Module, Function, Args) on the node Node. +%%% No response is delivered and the process which makes the call is +%%% not suspended until the evaluation is compleated as in the case of +%%% call/[3,4]. If Node is {Fun, FunArgs} applying +%%% Fun to FunArgs should return a node name. +cast(Node, Module, Function, Args) -> + cast(Node, Module, Function, Args, []). + +%%% @spec cast(Node, Module, Function, Args, Cookie) -> ok +%%% Node = NodeName | {Fun, FunArgs} +%%% Fun = fun() +%%% FunArgs = term() +%%% NodeName = atom() +%%% Module = atom() +%%% Function = atom() +%%% Args = [term()] +%%% Reason = timeout | term() +%%% Cookie = atom() +%%% +%%% @doc Evaluates apply(Module, Function, Args) on the node Node. +%%% No response is delivered and the process which makes the call is +%%% not suspended until the evaluation is compleated as in the case of +%%% call/[3,4]. If Node is {Fun, FunArgs} applying +%%% Fun to FunArgs should return a node name. +%%% The cookie on the client node will be set to <code>Cookie</code> +%%% for this rpc operation (use to match the server node cookie). +cast({Fun, FunArgs}, Module, Function, Args, Cookie) -> + Node = Fun(FunArgs), + cast(Node, Module, Function, Args, Cookie); +cast(Node, Module, Function, Args, Cookie) when is_atom(Node) -> + Cookie0 = set_the_cookie(Cookie), + true = rpc:cast(Node, Module, Function, Args), + set_the_cookie(Cookie0), + ok. + + +%%%---------- Internal ----------- + +%%% @hidden +set_the_cookie([]) -> + []; +set_the_cookie(Cookie) -> + Cookie0 = erlang:get_cookie(), + erlang:set_cookie(node(),Cookie), + Cookie0. diff --git a/lib/common_test/src/ct_run.erl b/lib/common_test/src/ct_run.erl new file mode 100644 index 0000000000..a1e2358578 --- /dev/null +++ b/lib/common_test/src/ct_run.erl @@ -0,0 +1,1812 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework test execution control module. +%%% +%%% <p>This module exports functions for installing and running tests +%%% withing the Common Test Framework.</p> + +-module(ct_run). + + +%% Script interface +-export([script_start/0,script_usage/0]). + +%% User interface +-export([install/1,install/2,run/1,run/2,run/3,run_test/1, + run_testspec/1,step/3,step/4,refresh_logs/1]). + + +%% Exported for VTS +-export([run_make/3,do_run/3,tests/1,tests/2,tests/3]). + + +%% Misc internal functions +-export([variables_file_name/1,script_start1/2,run_test1/1]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). + +-define(abs(Name), filename:absname(Name)). +-define(testdir(Name, Suite), ct_util:get_testdir(Name, Suite)). + +%%%----------------------------------------------------------------- +%%% @spec script_start() -> void() +%%% +%%% @doc Start tests via the run_test script. +%%% +%%% <p>Example:<br/><code>./run_test -config config.ctc -dir +%%% $TEST_DIR</code></p> +%%% +%%% <p>Example:<br/><code>./run_test -config config.ctc -suite +%%% $SUITE_PATH/$SUITE_NAME [-case $CASE_NAME]</code></p> +%%% +script_start() -> + process_flag(trap_exit, true), + Args = merge_arguments(init:get_arguments()), + Tracing = start_trace(Args), + Res = + case ct_repeat:loop_test(script, Args) of + false -> + {ok,Cwd} = file:get_cwd(), + CTVsn = + case filename:basename(code:lib_dir(common_test)) of + CTBase when is_list(CTBase) -> + case string:tokens(CTBase, "-") of + ["common_test",Vsn] -> " v"++Vsn; + _ -> "" + end + end, + io:format("~nCommon Test~s starting (cwd is ~s)~n~n", [CTVsn,Cwd]), + Self = self(), + Pid = spawn_link(fun() -> script_start1(Self, Args) end), + receive + {'EXIT',Pid,Reason} -> + case Reason of + {user_error,What} -> + io:format("\nTest run failed!\nReason: ~p\n\n", [What]), + {error,What}; + _ -> + io:format("Test run crashed! This could be an internal error " + "- please report!\n\n" + "~p\n\n", [Reason]), + {error,Reason} + end; + {Pid,{error,Reason}} -> + io:format("\nTest run failed! Reason:\n~p\n\n",[Reason]), + {error,Reason}; + {Pid,Result} -> + Result + end; + Result -> + Result + end, + stop_trace(Tracing), + Res. + +script_start1(Parent, Args) -> + case lists:keymember(preload, 1, Args) of + true -> preload(); + false -> ok + end, + + VtsOrShell = + case lists:keymember(vts, 1, Args) of + true -> + vts; + false -> + case lists:keymember(shell, 1, Args) of + true -> shell; + false -> false + end + end, + LogDir = + case lists:keysearch(logdir, 1, Args) of + {value,{logdir,[LogD]}} -> LogD; + false -> "." + end, + EvHandlers = + case lists:keysearch(event_handler, 1, Args) of + {value,{event_handler,Handlers}} -> + lists:map(fun(H) -> {list_to_atom(H),[]} end, Handlers); + false -> + [] + end, + Cover = + case lists:keysearch(cover, 1, Args) of + {value,{cover,CoverFile}} -> + {cover,?abs(CoverFile)}; + false -> + false + end, + + case lists:keysearch(ct_decrypt_key, 1, Args) of + {value,{_,[DecryptKey]}} -> + application:set_env(common_test, decrypt, {key,DecryptKey}); + false -> + case lists:keysearch(ct_decrypt_file, 1, Args) of + {value,{_,[DecryptFile]}} -> + application:set_env(common_test, decrypt, + {file,filename:absname(DecryptFile)}); + false -> + application:unset_env(common_test, decrypt) + end + end, + + case lists:keysearch(no_auto_compile, 1, Args) of + {value,_} -> + application:set_env(common_test, auto_compile, false); + false -> + application:set_env(common_test, auto_compile, true), + + InclDirs = + case lists:keysearch(include,1,Args) of + {value,{include,Incl}} when is_list(hd(Incl)) -> + Incl; + {value,{include,Incl}} when is_list(Incl) -> + [Incl]; + false -> + [] + end, + case os:getenv("CT_INCLUDE_PATH") of + false -> + application:set_env(common_test, include, InclDirs); + CtInclPath -> + InclDirs1 = string:tokens(CtInclPath,[$:,$ ,$,]), + application:set_env(common_test, include, InclDirs1++InclDirs) + end + end, + + case lists:keysearch(basic_html, 1, Args) of + {value,_} -> + application:set_env(common_test, basic_html, true); + false -> + application:set_env(common_test, basic_html, false) + end, + + Result = + case lists:keysearch(refresh_logs, 1, Args) of + {value,{refresh_logs,Refresh}} -> + LogDir1 = case Refresh of + [] -> LogDir; + [RefreshDir] -> ?abs(RefreshDir) + end, + {ok,Cwd} = file:get_cwd(), + file:set_cwd(LogDir1), + timer:sleep(500), % give the shell time to print version etc + io:nl(), + case catch ct_logs:make_all_suites_index(refresh) of + {'EXIT',ASReason} -> + file:set_cwd(Cwd), + {error,{all_suites_index,ASReason}}; + _ -> + case catch ct_logs:make_all_runs_index(refresh) of + {'EXIT',ARReason} -> + file:set_cwd(Cwd), + {error,{all_runs_index,ARReason}}; + _ -> + file:set_cwd(Cwd), + io:format("Logs in ~s refreshed!~n~n", [LogDir1]), + timer:sleep(500), % time to flush io before quitting + ok + end + end; + false -> + case lists:keysearch(ct_config, 1, Args) of + {value,{ct_config,ConfigFiles}} -> + case lists:keysearch(spec, 1, Args) of + false -> + case get_configfiles(ConfigFiles, [], LogDir, + EvHandlers) of + ok -> + script_start2(VtsOrShell, ConfigFiles, + EvHandlers, Args, LogDir, + Cover); + Error -> + Error + end; + _ -> + script_start2(VtsOrShell, ConfigFiles, + EvHandlers, Args, LogDir, Cover) + end; + false -> + case install([{config,[]}, + {event_handler,EvHandlers}], + LogDir) of + ok -> + script_start2(VtsOrShell, [], EvHandlers, + Args, LogDir, Cover); + Error -> + Error + end + end + end, + Parent ! {self(), Result}. + +get_configfiles([File|Files], Acc, LogDir, EvHandlers) -> + case filelib:is_file(File) of + true -> + get_configfiles(Files, [?abs(File)|Acc], + LogDir, EvHandlers); + false -> + {error,{cant_read_config_file,File}} + end; +get_configfiles([], Acc, LogDir, EvHandlers) -> + install([{config,lists:reverse(Acc)}, {event_handler,EvHandlers}], LogDir). + +script_start2(false, ConfigFiles, EvHandlers, Args, LogDir, Cover) -> + case lists:keysearch(spec, 1, Args) of + {value,{spec,[]}} -> + {error,no_testspec_specified}; + {value,{spec,Specs}} -> + Relaxed = lists:keymember(allow_user_terms, 1, Args), + %% using testspec as input for test + case catch ct_testspec:collect_tests_from_file(Specs, Relaxed) of + {error,Reason} -> + {error,Reason}; + TS -> + {LogDir1,TSCoverFile,ConfigFiles1,EvHandlers1,Include1} = + get_data_for_node(TS,node()), + UserInclude = + case application:get_env(common_test, include) of + {ok,Include} -> Include++Include1; + _ -> Include1 + end, + application:set_env(common_test, include, UserInclude), + LogDir2 = which_logdir(LogDir,LogDir1), + CoverOpt = case {Cover,TSCoverFile} of + {false,undef} -> []; + {_,undef} -> [Cover]; + {false,_} -> [{cover,TSCoverFile}] + end, + case get_configfiles(ConfigFiles++ConfigFiles1, + [], LogDir2, + EvHandlers++EvHandlers1) of + ok -> + {Run,Skip} = ct_testspec:prepare_tests(TS, node()), + do_run(Run, Skip, CoverOpt, Args, LogDir2); + Error -> + Error + end + end; + false -> + script_start3(false, ConfigFiles, EvHandlers, Args, LogDir, Cover) + end; +script_start2(VtsOrShell, ConfigFiles, EvHandlers, Args, LogDir, Cover) -> + script_start3(VtsOrShell, ConfigFiles, EvHandlers, Args, LogDir, Cover). + +script_start3(VtsOrShell, ConfigFiles, EvHandlers, Args, LogDir, Cover) -> + case lists:keysearch(dir, 1, Args) of + {value,{dir,[]}} -> + {error,no_dir_specified}; + {value,{dir,Dirs}} -> + script_start4(VtsOrShell, ConfigFiles, EvHandlers, tests(Dirs), + Cover, Args, LogDir); + false -> + case lists:keysearch(suite, 1, Args) of + {value,{suite,[]}} -> + {error,no_suite_specified}; + {value,{suite,Suites}} -> + StepOrCover = + case lists:keysearch(step, 1, Args) of + {value,Step} -> Step; + false -> Cover + end, + S2M = fun(S) -> + {filename:dirname(S), + list_to_atom( + filename:rootname(filename:basename(S)))} + end, + DirMods = lists:map(S2M, Suites), + {Specified,GroupsAndCases} = + case {lists:keysearch(group, 1, Args), + lists:keysearch('case', 1, Args)} of + {{value,{_,Gs}},{value,{_,Cs}}} -> {true,Gs++Cs}; + {{value,{_,Gs}},_} -> {true,Gs}; + {_,{value,{_,Cs}}} -> {true,Cs}; + _ -> {false,[]} + end, + if Specified, length(GroupsAndCases) == 0 -> + {error,no_case_or_group_specified}; + Specified, length(DirMods) > 1 -> + {error,multiple_suites_and_cases}; + length(GroupsAndCases) > 0, length(DirMods) == 1 -> + GsAndCs = lists:map(fun(C) -> list_to_atom(C) end, + GroupsAndCases), + script_start4(VtsOrShell, ConfigFiles, EvHandlers, + tests(DirMods, GsAndCs), + StepOrCover, Args, LogDir); + not Specified, length(DirMods) > 0 -> + script_start4(VtsOrShell, ConfigFiles, EvHandlers, + tests(DirMods), + StepOrCover, Args, LogDir); + true -> + {error,incorrect_suite_and_case_options} + end; + false when VtsOrShell=/=false -> + script_start4(VtsOrShell, ConfigFiles, EvHandlers, + [], Cover, Args, LogDir); + false -> + script_usage(), + {error,incorrect_usage} + end + end. + +script_start4(vts, ConfigFiles, EvHandlers, Tests, false, _Args, LogDir) -> + vts:init_data(ConfigFiles, EvHandlers, ?abs(LogDir), Tests); +script_start4(shell, ConfigFiles, EvHandlers, _Tests, false, Args, LogDir) -> + Opts = [{config,ConfigFiles},{event_handler,EvHandlers}], + if ConfigFiles == [] -> + ok; + true -> + io:format("\nInstalling: ~p\n\n", [ConfigFiles]) + end, + case install(Opts) of + ok -> + ct_util:start(interactive, LogDir), + log_ts_names(Args), + io:nl(), + ok; + Error -> + Error + end; +script_start4(vts, _CfgFs, _EvHs, _Tests, _Cover={cover,_}, _Args, _LogDir) -> + %% Add support later (maybe). + script_usage(), + erlang:halt(); +script_start4(shell, _CfgFs, _EvHs, _Tests, _Cover={cover,_}, _Args, _LogDir) -> + %% Add support later (maybe). + script_usage(); +script_start4(false, _CfgFs, _EvHs, Tests, Cover={cover,_}, Args, LogDir) -> + do_run(Tests, [], [Cover], Args, LogDir); +script_start4(false, _ConfigFiles, _EvHandlers, Tests, false, Args, LogDir) -> + do_run(Tests, [], [], Args, LogDir); +script_start4(false, _ConfigFiles, _EvHandlers, Test, Step, Args, LogDir) -> + do_run(Test, [], [Step], Args, LogDir); +script_start4(vts, _ConfigFiles, _EvHandlers, _Test, _Step, _Args, _LogDir) -> + script_usage(), + erlang:halt(); +script_start4(shell, _ConfigFiles, _EvHandlers, _Test, _Step, _Args, _LogDir) -> + script_usage(). + +%%%----------------------------------------------------------------- +%%% @spec script_usage() -> ok +%%% @doc Print script usage information for <code>run_test</code>. +script_usage() -> + io:format("\n\nUsage:\n\n"), + io:format("Run tests in web based GUI:\n\n" + "\trun_test -vts [-browser Browser]" + "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]" + "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]" + "\n\t[-dir TestDir1 TestDir2 .. TestDirN] |" + "\n\t[-suite Suite [-case Case]]" + "\n\t[-include InclDir1 InclDir2 .. InclDirN]" + "\n\t[-no_auto_compile]" + "\n\t[-basic_html]\n\n"), + io:format("Run tests from command line:\n\n" + "\trun_test [-dir TestDir1 TestDir2 .. TestDirN] |" + "\n\t[-suite Suite1 Suite2 .. SuiteN [-case Case1 Case2 .. CaseN]]" + "\n\t[-step [config | keep_inactive]]" + "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]" + "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]" + "\n\t[-logdir LogDir]" + "\n\t[-silent_connections [ConnType1 ConnType2 .. ConnTypeN]]" + "\n\t[-stylesheet CSSFile]" + "\n\t[-cover CoverCfgFile]" + "\n\t[-event_handler EvHandler1 EvHandler2 .. EvHandlerN]" + "\n\t[-include InclDir1 InclDir2 .. InclDirN]" + "\n\t[-no_auto_compile]" + "\n\t[-basic_html]" + "\n\t[-repeat N [-force_stop]] |" + "\n\t[-duration HHMMSS [-force_stop]] |" + "\n\t[-until [YYMoMoDD]HHMMSS [-force_stop]]\n\n"), + io:format("Run tests using test specification:\n\n" + "\trun_test -spec TestSpec1 TestSpec2 .. TestSpecN" + "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]" + "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]" + "\n\t[-logdir LogDir]" + "\n\t[-allow_user_terms]" + "\n\t[-silent_connections [ConnType1 ConnType2 .. ConnTypeN]]" + "\n\t[-stylesheet CSSFile]" + "\n\t[-cover CoverCfgFile]" + "\n\t[-event_handler EvHandler1 EvHandler2 .. EvHandlerN]" + "\n\t[-include InclDir1 InclDir2 .. InclDirN]" + "\n\t[-no_auto_compile]" + "\n\t[-basic_html]" + "\n\t[-repeat N [-force_stop]] |" + "\n\t[-duration HHMMSS [-force_stop]] |" + "\n\t[-until [YYMoMoDD]HHMMSS [-force_stop]]\n\n"), + io:format("Refresh the HTML index files:\n\n" + "\trun_test -refresh_logs [LogDir]" + "[-logdir LogDir] " + "[-basic_html]\n\n"), + io:format("Run CT in interactive mode:\n\n" + "\trun_test -shell" + "\n\t[-config ConfigFile1 ConfigFile2 .. ConfigFileN]" + "\n\t[-decrypt_key Key] | [-decrypt_file KeyFile]\n\n"). + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:install/1 +install(Opts) -> + install(Opts, "."). + +install(Opts, LogDir) -> + case application:get_env(common_test, decrypt) of + {ok,_} -> + ok; + _ -> + case lists:keysearch(decrypt, 1, Opts) of + {value,{_,KeyOrFile}} -> + application:set_env(common_test, decrypt, KeyOrFile); + false -> + application:unset_env(common_test, decrypt) + end + end, + case whereis(ct_util_server) of + undefined -> + VarFile = variables_file_name(LogDir), + case file:open(VarFile, [write]) of + {ok,Fd} -> + [io:format(Fd, "~p.\n", [Opt]) || Opt <- Opts], + file:close(Fd), + ok; + {error,Reason} -> + io:format("CT failed to install configuration data. Please " + "verify that the log directory exists and that " + "write permission is set.\n\n", []), + {error,{VarFile,Reason}} + end; + _ -> + io:format("It is not possible to install CT while running " + "in interactive mode.\n" + "To exit this mode, run ct:stop_interactive().\n" + "To enter the interactive mode again, " + "run ct:start_interactive()\n\n", []), + {error,interactive_mode} + end. + +variables_file_name(Dir) -> + filename:join(Dir, "variables-"++atom_to_list(node())). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:run_test/1 + +%% Opts = [OptTuples] +%% OptTuples = {config,CfgFiles} | {dir,TestDirs} | {suite,Suites} | +%% {testcase,Cases} | {spec,TestSpecs} | {allow_user_terms,Bool} | +%% {logdir,LogDir} | {cover,CoverSpecFile} | {step,StepOpts} | +%% {silent_connections,Conns} | {event_handler,EventHandlers} | +%% {include,InclDirs} | {auto_compile,Bool} | +%% {repeat,N} | {duration,DurTime} | {until,StopTime} | {force_stop,Bool} | +%% {decrypt,KeyOrFile} + +run_test(Opt) when is_tuple(Opt) -> + run_test([Opt]); + +run_test(Opts) when is_list(Opts) -> + case lists:keysearch(refresh_logs, 1, Opts) of + {value,{_,RefreshDir}} -> + refresh_logs(?abs(RefreshDir)), + ok; + false -> + Tracing = start_trace(Opts), + {ok,Cwd} = file:get_cwd(), + io:format("~nCommon Test starting (cwd is ~s)~n~n", [Cwd]), + Res = + case ct_repeat:loop_test(func, Opts) of + false -> + case catch run_test1(Opts) of + {'EXIT',Reason} -> + file:set_cwd(Cwd), + {error,Reason}; + Result -> + Result + end; + Result -> + Result + end, + stop_trace(Tracing), + Res + end. + +run_test1(Opts) -> + LogDir = + case lists:keysearch(logdir, 1, Opts) of + {value,{_,LD}} when is_list(LD) -> LD; + false -> "." + end, + CfgFiles = + case lists:keysearch(config, 1, Opts) of + {value,{_,Files=[File|_]}} when is_list(File) -> + Files; + {value,{_,File=[C|_]}} when is_integer(C) -> + [File]; + {value,{_,[]}} -> + []; + false -> + [] + end, + EvHandlers = + case lists:keysearch(event_handler, 1, Opts) of + {value,{_,H}} when is_atom(H) -> + [{H,[]}]; + {value,{_,H}} -> + Hs = + if is_tuple(H) -> [H]; + is_list(H) -> H; + true -> [] + end, + lists:flatten( + lists:map(fun(EH) when is_atom(EH) -> + {EH,[]}; + ({HL,Args}) when is_list(HL) -> + [{EH,Args} || EH <- HL]; + ({EH,Args}) when is_atom(EH) -> + {EH,Args}; + (_) -> + [] + end, Hs)); + _ -> + [] + end, + SilentConns = + case lists:keysearch(silent_connections, 1, Opts) of + {value,{_,all}} -> + []; + {value,{_,Conns}} -> + Conns; + _ -> + undefined + end, + Cover = + case lists:keysearch(cover, 1, Opts) of + {value,{_,CoverFile}} -> + [{cover,?abs(CoverFile)}]; + _ -> + [] + end, + Include = + case lists:keysearch(auto_compile, 1, Opts) of + {value,{auto_compile,ACBool}} -> + application:set_env(common_test, auto_compile, ACBool), + []; + _ -> + application:set_env(common_test, auto_compile, true), + InclDirs = + case lists:keysearch(include, 1, Opts) of + {value,{include,Incl}} when is_list(hd(Incl)) -> + Incl; + {value,{include,Incl}} when is_list(Incl) -> + [Incl]; + false -> + [] + end, + case os:getenv("CT_INCLUDE_PATH") of + false -> + application:set_env(common_test, include, InclDirs), + InclDirs; + CtInclPath -> + InclDirs1 = string:tokens(CtInclPath, [$:,$ ,$,]), + AllInclDirs = InclDirs1++InclDirs, + application:set_env(common_test, include, AllInclDirs), + AllInclDirs + end + end, + + case lists:keysearch(decrypt, 1, Opts) of + {value,{_,Key={key,_}}} -> + application:set_env(common_test, decrypt, Key); + {value,{_,{file,KeyFile}}} -> + application:set_env(common_test, decrypt, {file,filename:absname(KeyFile)}); + false -> + application:unset_env(common_test, decrypt) + end, + + case lists:keysearch(basic_html, 1, Opts) of + {value,{basic_html,BasicHtmlBool}} -> + application:set_env(common_test, basic_html, BasicHtmlBool); + _ -> + application:set_env(common_test, basic_html, false) + end, + + case lists:keysearch(spec, 1, Opts) of + {value,{_,Specs}} -> + Relaxed = + case lists:keysearch(allow_user_terms, 1, Opts) of + {value,{_,true}} -> true; + _ -> false + end, + %% using testspec(s) as input for test + run_spec_file(LogDir, CfgFiles, EvHandlers, Include, Specs, Relaxed, Cover, + replace_opt([{silent_connections,SilentConns}], Opts)); + false -> + case lists:keysearch(prepared_tests, 1, Opts) of + {value,{_,{Run,Skip},Specs}} -> % use prepared tests + run_prepared(LogDir, CfgFiles, EvHandlers, + Run, Skip, Cover, + replace_opt([{silent_connections,SilentConns}, + {spec,Specs}],Opts)); + false -> % use dir|suite|case + StepOrCover = + case lists:keysearch(step, 1, Opts) of + {value,Step} -> [Step]; + false -> Cover + end, + run_dir(LogDir, CfgFiles, EvHandlers, StepOrCover, + replace_opt([{silent_connections,SilentConns}], Opts)) + end + end. + +replace_opt([O={Key,_Val}|Os], Opts) -> + [O | replace_opt(Os, lists:keydelete(Key, 1, Opts))]; +replace_opt([], Opts) -> + Opts. + +run_spec_file(LogDir, CfgFiles, EvHandlers, Include, Specs, Relaxed, Cover, Opts) -> + Specs1 = case Specs of + [X|_] when is_integer(X) -> [Specs]; + _ -> Specs + end, + AbsSpecs = lists:map(fun(SF) -> ?abs(SF) end, Specs1), + log_ts_names(AbsSpecs), + case catch ct_testspec:collect_tests_from_file(AbsSpecs, Relaxed) of + {error,CTReason} -> + exit(CTReason); + TS -> + {LogDir1,TSCoverFile,CfgFiles1,EvHandlers1,Include1} = + get_data_for_node(TS, node()), + application:set_env(common_test, include, Include++Include1), + LogDir2 = which_logdir(LogDir, LogDir1), + CoverOpt = case {Cover,TSCoverFile} of + {[],undef} -> []; + {_,undef} -> Cover; + {[],_} -> [{cover,TSCoverFile}] + end, + case get_configfiles(CfgFiles++CfgFiles1, [], LogDir2, + EvHandlers++EvHandlers1) of + ok -> + {Run,Skip} = ct_testspec:prepare_tests(TS, node()), + do_run(Run, Skip, CoverOpt, + replace_opt([{spec,AbsSpecs}], Opts), + LogDir2); + {error,GCFReason} -> + exit(GCFReason) + end + end. + +run_prepared(LogDir, CfgFiles, EvHandlers, Run, Skip, Cover, Opts) -> + case get_configfiles(CfgFiles, [], LogDir, EvHandlers) of + ok -> + do_run(Run, Skip, Cover, Opts, LogDir); + {error,Reason} -> + exit(Reason) + end. + +run_dir(LogDir, CfgFiles, EvHandlers, StepOrCover, Opts) -> + AbsCfgFiles = + lists:map(fun(F) -> + AbsName = ?abs(F), + case filelib:is_file(AbsName) of + true -> AbsName; + false -> exit({no_such_file,AbsName}) + end + end, CfgFiles), + + case install([{config,AbsCfgFiles},{event_handler,EvHandlers}], LogDir) of + ok -> ok; + {error,IReason} -> exit(IReason) + end, + case lists:keysearch(dir,1,Opts) of + {value,{_,Dirs=[Dir|_]}} when not is_integer(Dir), + length(Dirs)>1 -> + %% multiple dirs (no suite) + do_run(tests(Dirs), [], StepOrCover, Opts, LogDir); + false -> % no dir + %% fun for converting suite name to {Dir,Mod} tuple + S2M = fun(S) when is_list(S) -> + {filename:dirname(S), + list_to_atom(filename:rootname(filename:basename(S)))}; + (A) -> + {".",A} + end, + case lists:keysearch(suite, 1, Opts) of + {value,{_,Suite}} when is_integer(hd(Suite)) ; is_atom(Suite) -> + {Dir,Mod} = S2M(Suite), + case listify(proplists:get_value(group, Opts, [])) ++ + listify(proplists:get_value(testcase, Opts, [])) of + [] -> + do_run(tests(Dir, listify(Mod)), [], StepOrCover, Opts, LogDir); + GsAndCs -> + do_run(tests(Dir, Mod, GsAndCs), [], StepOrCover, Opts, LogDir) + end; + {value,{_,Suites}} -> + do_run(tests(lists:map(S2M, Suites)), [], StepOrCover, Opts, LogDir); + _ -> + exit(no_tests_specified) + end; + {value,{_,Dir}} -> + case lists:keysearch(suite, 1, Opts) of + {value,{_,Suite}} when is_integer(hd(Suite)) ; is_atom(Suite) -> + Mod = if is_atom(Suite) -> Suite; + true -> list_to_atom(Suite) + end, + case listify(proplists:get_value(group, Opts, [])) ++ + listify(proplists:get_value(testcase, Opts, [])) of + [] -> + do_run(tests(Dir, listify(Mod)), [], StepOrCover, Opts, LogDir); + GsAndCs -> + do_run(tests(Dir, Mod, GsAndCs), [], StepOrCover, Opts, LogDir) + end; + {value,{_,Suites=[Suite|_]}} when is_list(Suite) -> + Mods = lists:map(fun(Str) -> list_to_atom(Str) end, Suites), + do_run(tests(delistify(Dir), Mods), [], StepOrCover, Opts, LogDir); + {value,{_,Suites}} -> + do_run(tests(delistify(Dir), Suites), [], StepOrCover, Opts, LogDir); + false -> % no suite, only dir + do_run(tests(listify(Dir)), [], StepOrCover, Opts, LogDir) + end + end. + +%%%----------------------------------------------------------------- +%%% @hidden +%%% + +%% using testspec(s) as input for test +run_testspec(TestSpec) -> + {ok,Cwd} = file:get_cwd(), + io:format("~nCommon Test starting (cwd is ~s)~n~n", [Cwd]), + case catch run_testspec1(TestSpec) of + {'EXIT',Reason} -> + file:set_cwd(Cwd), + {error,Reason}; + Result -> + Result + end. + +run_testspec1(TestSpec) -> + case ct_testspec:collect_tests_from_list(TestSpec,false) of + {error,CTReason} -> + exit(CTReason); + TS -> + {LogDir,TSCoverFile,CfgFiles,EvHandlers,Include} = + get_data_for_node(TS,node()), + case os:getenv("CT_INCLUDE_PATH") of + false -> + application:set_env(common_test, include, Include); + CtInclPath -> + EnvInclude = string:tokens(CtInclPath, [$:,$ ,$,]), + application:set_env(common_test, include, EnvInclude++Include) + end, + CoverOpt = if TSCoverFile == undef -> []; + true -> [{cover,TSCoverFile}] + end, + case get_configfiles(CfgFiles,[],LogDir,EvHandlers) of + ok -> + {Run,Skip} = ct_testspec:prepare_tests(TS,node()), + do_run(Run,Skip,CoverOpt,[],LogDir); + {error,GCFReason} -> + exit(GCFReason) + end + end. + + +get_data_for_node(#testspec{logdir=LogDirs, + cover=CoverFs, + config=Cfgs, + event_handler=EvHs, + include=Incl}, Node) -> + LogDir = case lists:keysearch(Node,1,LogDirs) of + {value,{Node,Dir}} -> Dir; + false -> "." + end, + Cover = case lists:keysearch(Node,1,CoverFs) of + {value,{Node,CovFile}} -> CovFile; + false -> undef + end, + ConfigFiles = [F || {N,F} <- Cfgs, N==Node], + EvHandlers = [{H,A} || {N,H,A} <- EvHs, N==Node], + Include = [I || {N,I} <- Incl, N==Node], + {LogDir,Cover,ConfigFiles,EvHandlers,Include}. + + +refresh_logs(LogDir) -> + {ok,Cwd} = file:get_cwd(), + case file:set_cwd(LogDir) of + E = {error,_Reason} -> + E; + _ -> + case catch ct_logs:make_all_suites_index(refresh) of + {'EXIT',ASReason} -> + file:set_cwd(Cwd), + {error,{all_suites_index,ASReason}}; + _ -> + case catch ct_logs:make_all_runs_index(refresh) of + {'EXIT',ARReason} -> + file:set_cwd(Cwd), + {error,{all_runs_index,ARReason}}; + _ -> + file:set_cwd(Cwd), + io:format("Logs in ~s refreshed!~n",[LogDir]), + ok + end + end + end. + +which_logdir(".",Dir) -> + Dir; +which_logdir(Dir,_) -> + Dir. + +listify([C|_]=Str) when is_integer(C) -> [Str]; +listify(L) when is_list(L) -> L; +listify(E) -> [E]. + +delistify([E]) -> E; +delistify(E) -> E. + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:run/3 +run(TestDir, Suite, Cases) -> + install([]), + do_run(tests(TestDir, Suite, Cases), []). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:run/2 +run(TestDir, Suite) when is_list(TestDir), is_integer(hd(TestDir)) -> + install([]), + do_run(tests(TestDir, Suite), []). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:run/1 +run(TestDirs) -> + install([]), + do_run(tests(TestDirs), []). + + +tests(TestDir, Suites, []) when is_list(TestDir), is_integer(hd(TestDir)) -> + [{?testdir(TestDir,Suites),ensure_atom(Suites),all}]; +tests(TestDir, Suite, Cases) when is_list(TestDir), is_integer(hd(TestDir)) -> + [{?testdir(TestDir,Suite),ensure_atom(Suite),Cases}]. +tests([{Dir,Suite}],Cases) -> + [{?testdir(Dir,Suite),ensure_atom(Suite),Cases}]; +tests(TestDir, Suite) when is_list(TestDir), is_integer(hd(TestDir)) -> + tests(TestDir, ensure_atom(Suite), all). +tests(DirSuites) when is_list(DirSuites), is_tuple(hd(DirSuites)) -> + [{?testdir(Dir,Suite),ensure_atom(Suite),all} || {Dir,Suite} <- DirSuites]; +tests(TestDir) when is_list(TestDir), is_integer(hd(TestDir)) -> + tests([TestDir]); +tests(TestDirs) when is_list(TestDirs), is_list(hd(TestDirs)) -> + [{?testdir(TestDir,all),all,all} || TestDir <- TestDirs]. + +do_run(Tests, Opt) -> + do_run(Tests, [], Opt, [], "."). + +do_run(Tests, Opt, LogDir) -> + do_run(Tests, [], Opt, [], LogDir). + +do_run(Tests, Skip, Opt, Args, LogDir) -> + case code:which(test_server) of + non_existing -> + exit({error,no_path_to_test_server}); + _ -> + Opt1 = + case lists:keysearch(cover, 1, Opt) of + {value,{_,CoverFile}} -> + case ct_cover:get_spec(CoverFile) of + {error,Reason} -> + exit({error,Reason}); + Spec -> + [{cover_spec,Spec} | + lists:keydelete(cover, 1, Opt)] + end; + _ -> + Opt + end, + %% This env variable is used by test_server to determine + %% which framework it runs under. + case os:getenv("TEST_SERVER_FRAMEWORK") of + false -> + os:putenv("TEST_SERVER_FRAMEWORK", "ct_framework"); + "ct_framework" -> + ok; + Other -> + erlang:display(list_to_atom("Note: TEST_SERVER_FRAMEWORK = " ++ Other)) + end, + case ct_util:start(LogDir) of + {error,interactive_mode} -> + io:format("CT is started in interactive mode. " + "To exit this mode, run ct:stop_interactive().\n" + "To enter the interactive mode again, " + "run ct:start_interactive()\n\n",[]), + {error,interactive_mode}; + + _Pid -> + %% save style sheet info + case lists:keysearch(stylesheet, 1, Args) of + {value,{_,SSFile}} -> + ct_util:set_testdata({stylesheet,SSFile}); + _ -> + ct_util:set_testdata({stylesheet,undefined}) + end, + + case lists:keysearch(silent_connections, 1, Args) of + {value,{silent_connections,undefined}} -> + ok; + {value,{silent_connections,[]}} -> + Conns = ct_util:override_silence_all_connections(), + ct_logs:log("Silent connections", "~p", [Conns]); + {value,{silent_connections,Cs}} -> + Conns = lists:map(fun(S) when is_list(S) -> + list_to_atom(S); + (A) -> A + end, Cs), + ct_util:override_silence_connections(Conns), + ct_logs:log("Silent connections", "~p", [Conns]); + _ -> + ok + end, + log_ts_names(Args), + TestSuites = suite_tuples(Tests), + + {SuiteMakeErrors,AllMakeErrors} = + case application:get_env(common_test, auto_compile) of + {ok,false} -> + SuitesNotFound = verify_suites(TestSuites), + {SuitesNotFound,SuitesNotFound}; + _ -> + {SuiteErrs,HelpErrs} = auto_compile(TestSuites), + {SuiteErrs,SuiteErrs++HelpErrs} + end, + + case continue(AllMakeErrors) of + true -> + SavedErrors = save_make_errors(SuiteMakeErrors), + ct_repeat:log_loop_info(Args), + {Tests1,Skip1} = final_tests(Tests,[],Skip,SavedErrors), + R = do_run_test(Tests1, Skip1, Opt1), + ct_util:stop(normal), + R; + false -> + io:nl(), + ct_util:stop(clean), + BadMods = + lists:foldr( + fun({{_,_},Ms}, Acc) -> + Ms ++ lists:foldl( + fun(M, Acc1) -> + lists:delete(M, Acc1) + end, Acc, Ms) + end, [], AllMakeErrors), + {error,{make_failed,BadMods}} + end + end + end. + +%% attempt to compile the modules specified in TestSuites +auto_compile(TestSuites) -> + io:format("~nCommon Test: Running make in test directories...~n"), + UserInclude = + case application:get_env(common_test, include) of + {ok,UserInclDirs} when length(UserInclDirs) > 0 -> + io:format("Including the following directories:~n"), + [begin io:format("~p~n",[UserInclDir]), {i,UserInclDir} end || + UserInclDir <- UserInclDirs]; + _ -> + [] + end, + SuiteMakeErrors = + lists:flatmap(fun({TestDir,Suite} = TS) -> + case run_make(suites, TestDir, Suite, UserInclude) of + {error,{make_failed,Bad}} -> + [{TS,Bad}]; + {error,_} -> + [{TS,[filename:join(TestDir,"*_SUITE")]}]; + _ -> + [] + end + end, TestSuites), + + %% try to compile other modules than SUITEs in the test directories + {_,HelpMakeErrors} = + lists:foldl( + fun({Dir,Suite}, {Done,Failed}) -> + case lists:member(Dir, Done) of + false -> + Failed1 = + case run_make(helpmods, Dir, Suite, UserInclude) of + {error,{make_failed,BadMods}} -> + [{{Dir,all},BadMods}|Failed]; + {error,_} -> + [{{Dir,all},[Dir]}|Failed]; + _ -> + Failed + end, + {[Dir|Done],Failed1}; + true -> % already visited + {Done,Failed} + end + end, {[],[]}, TestSuites), + {SuiteMakeErrors,lists:reverse(HelpMakeErrors)}. + +%% verify that specified test suites exist (if auto compile is disabled) +verify_suites(TestSuites) -> + io:nl(), + Verify = + fun({Dir,Suite},NotFound) -> + case locate_test_dir(Dir, Suite) of + {ok,TestDir} -> + if Suite == all -> + NotFound; + true -> + Beam = filename:join(TestDir, atom_to_list(Suite)++".beam"), + case filelib:is_regular(Beam) of + true -> + NotFound; + false -> + Name = filename:join(TestDir, atom_to_list(Suite)), + io:format("Suite ~w not found in directory ~s~n", + [Suite,TestDir]), + [{{Dir,Suite},[Name]} | NotFound] + end + end; + {error,_Reason} -> + io:format("Directory ~s is invalid~n", [Dir]), + Name = filename:join(Dir, atom_to_list(Suite)), + [{{Dir,Suite},[Name]} | NotFound] + end + end, + lists:reverse(lists:foldl(Verify, [], TestSuites)). + + +save_make_errors([]) -> + []; +save_make_errors(Errors) -> + Suites = get_bad_suites(Errors,[]), + ct_logs:log("MAKE RESULTS", + "Error compiling or locating the following suites: ~n~p",[Suites]), + %% save the info for logger + file:write_file(?missing_suites_info,term_to_binary(Errors)), + Errors. + +get_bad_suites([{{_TestDir,_Suite},Failed}|Errors], BadSuites) -> + get_bad_suites(Errors,BadSuites++Failed); +get_bad_suites([], BadSuites) -> + BadSuites. + + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:step/3 +step(TestDir, Suite, Case) -> + step(TestDir, Suite, Case, []). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:step/4 +step(TestDir, Suite, Case, Opts) when is_list(TestDir), is_atom(Suite), is_atom(Case), + Suite =/= all, Case =/= all -> + do_run([{TestDir,Suite,Case}], [{step,Opts}]). + + +%%%----------------------------------------------------------------- +%%% Internal +suite_tuples([{TestDir,Suites,_} | Tests]) when is_list(Suites) -> + lists:map(fun(S) -> {TestDir,S} end, Suites) ++ suite_tuples(Tests); +suite_tuples([{TestDir,Suite,_} | Tests]) when is_atom(Suite) -> + [{TestDir,Suite} | suite_tuples(Tests)]; +suite_tuples([]) -> + []. + +final_tests([{TestDir,Suites,_}|Tests], + Final, Skip, Bad) when is_list(Suites), is_atom(hd(Suites)) -> +% Separate = +% fun(S,{DoSuite,Dont}) -> +% case lists:keymember({TestDir,S},1,Bad) of +% false -> +% {[S|DoSuite],Dont}; +% true -> +% SkipIt = {TestDir,S,"Make failed"}, +% {DoSuite,Dont++[SkipIt]} +% end +% end, + +% {DoSuites,Skip1} = +% lists:foldl(Separate,{[],Skip},Suites), +% Do = {TestDir,lists:reverse(DoSuites),all}, + + Skip1 = [{TD,S,"Make failed"} || {{TD,S},_} <- Bad, S1 <- Suites, + S == S1, TD == TestDir], + Final1 = [{TestDir,S,all} || S <- Suites], + final_tests(Tests, lists:reverse(Final1)++Final, Skip++Skip1, Bad); + +final_tests([{TestDir,all,all}|Tests], Final, Skip, Bad) -> + MissingSuites = + case lists:keysearch({TestDir,all}, 1, Bad) of + {value,{_,Failed}} -> + [list_to_atom(filename:basename(F)) || F <- Failed]; + false -> + [] + end, + Missing = [{TestDir,S,"Make failed"} || S <- MissingSuites], + Final1 = [{TestDir,all,all}|Final], + final_tests(Tests, Final1, Skip++Missing, Bad); + +final_tests([{TestDir,Suite,Cases}|Tests], + Final, Skip, Bad) when Cases==[]; Cases==all -> + final_tests([{TestDir,[Suite],all}|Tests], Final, Skip, Bad); + +final_tests([{TestDir,Suite,Cases}|Tests], Final, Skip, Bad) -> + case lists:keymember({TestDir,Suite}, 1, Bad) of + false -> + Do = {TestDir,Suite,Cases}, + final_tests(Tests, [Do|Final], Skip, Bad); + true -> + Do = {TestDir,Suite,Cases}, + Skip1 = Skip ++ [{TestDir,Suite,Cases,"Make failed"}], + final_tests(Tests, [Do|Final], Skip1, Bad) + end; + +final_tests([], Final, Skip, _Bad) -> + {lists:reverse(Final),Skip}. + +continue([]) -> + true; +continue(_MakeErrors) -> + io:nl(), + OldGl = group_leader(), + case set_group_leader_same_as_shell() of + true -> + S = self(), + io:format("Failed to compile or locate one or more test suites\n" + "Press \'c\' to continue or \'a\' to abort.\n" + "Will continue in 15 seconds if no answer is given!\n"), + Pid = spawn(fun() -> + case io:get_line('(c/a) ') of + "c\n" -> + S ! true; + _ -> + S ! false + end + end), + group_leader(OldGl, self()), + receive R when R==true; R==false -> + R + after 15000 -> + exit(Pid, kill), + io:format("... timeout - continuing!!\n"), + true + end; + false -> % no shell process to use + true + end. + +set_group_leader_same_as_shell() -> + %%! Locate the shell process... UGLY!!! + GS2or3 = fun(P) -> + case process_info(P,initial_call) of + {initial_call,{group,server,X}} when X == 2 ; X == 3 -> + true; + _ -> + false + end + end, + case [P || P <- processes(), GS2or3(P), + true == lists:keymember(shell,1,element(2,process_info(P,dictionary)))] of + [GL|_] -> + group_leader(GL, self()); + [] -> + false + end. + +check_and_add([{TestDir0,M,_} | Tests], Added) -> + case locate_test_dir(TestDir0, M) of + {ok,TestDir} -> + case lists:member(TestDir, Added) of + true -> + check_and_add(Tests, Added); + false -> + true = code:add_patha(TestDir), + check_and_add(Tests, [TestDir|Added]) + end; + {error,_} -> + {error,{invalid_directory,TestDir0}} + end; +check_and_add([], _) -> + ok. + +do_run_test(Tests, Skip, Opt) -> + case check_and_add(Tests, []) of + ok -> + ct_util:set_testdata({stats,{0,0,{0,0}}}), + ct_util:set_testdata({cover,undefined}), + test_server_ctrl:start_link(local), + case lists:keysearch(cover_spec, 1, Opt) of + {value,{_,CovData={CovFile, + CovNodes, + _CovImport, + CovExport, + #cover{app = CovApp, + level = CovLevel, + excl_mods = CovExcl, + incl_mods = CovIncl, + cross = CovCross, + src = _CovSrc}}}} -> + ct_logs:log("COVER INFO","Using cover specification file: ~s~n" + "App: ~w~n" + "Cross cover: ~w~n" + "Including ~w modules~n" + "Excluding ~w modules", + [CovFile,CovApp,CovCross,length(CovIncl),length(CovExcl)]), + + %% cover export file will be used for export and import + %% between tests so make sure it doesn't exist initially + case filelib:is_file(CovExport) of + true -> + DelResult = file:delete(CovExport), + ct_logs:log("COVER INFO", + "Warning! Export file ~s already exists. " + "Deleting with result: ~p", + [CovExport,DelResult]); + false -> + ok + end, + + %% tell test_server which modules should be cover compiled + %% note that actual compilation is done when tests start + test_server_ctrl:cover(CovApp, CovFile, CovExcl, CovIncl, + CovCross, CovExport, CovLevel), + %% save cover data (used e.g. to add nodes dynamically) + ct_util:set_testdata({cover,CovData}), + %% start cover on specified nodes + if (CovNodes /= []) and (CovNodes /= undefined) -> + ct_logs:log("COVER INFO", + "Nodes included in cover session: ~w", + [CovNodes]), + cover:start(CovNodes); + true -> + ok + end, + true; + _ -> + false + end, + %% let test_server expand the test tuples and count no of cases + {Suites,NoOfCases} = count_test_cases(Tests, Skip), + Suites1 = delete_dups(Suites), + NoOfTests = length(Tests), + NoOfSuites = length(Suites1), + ct_util:warn_duplicates(Suites1), + {ok,Cwd} = file:get_cwd(), + io:format("~nCWD set to: ~p~n", [Cwd]), + if NoOfCases == unknown -> + io:format("~nTEST INFO: ~w test(s), ~w suite(s)~n~n", + [NoOfTests,NoOfSuites]), + ct_logs:log("TEST INFO","~w test(s), ~w suite(s)", + [NoOfTests,NoOfSuites]); + true -> + io:format("~nTEST INFO: ~w test(s), ~w case(s) in ~w suite(s)~n~n", + [NoOfTests,NoOfCases,NoOfSuites]), + ct_logs:log("TEST INFO","~w test(s), ~w case(s) in ~w suite(s)", + [NoOfTests,NoOfCases,NoOfSuites]) + end, + ct_event:notify(#event{name=start_info, + node=node(), + data={NoOfTests,NoOfSuites,NoOfCases}}), + CleanUp = add_jobs(Tests, Skip, Opt, []), + unlink(whereis(test_server_ctrl)), + catch test_server_ctrl:wait_finish(), + %% check if last testcase has left a "dead" trace window + %% behind, and if so, kill it + case ct_util:get_testdata(interpret) of + {_What,kill,{TCPid,AttPid}} -> + ct_util:kill_attached(TCPid, AttPid); + _ -> + ok + end, + lists:foreach(fun(Suite) -> + maybe_cleanup_interpret(Suite, Opt) + end, CleanUp); + Error -> + Error + end. + +delete_dups([S | Suites]) -> + Suites1 = lists:delete(S, Suites), + [S | delete_dups(Suites1)]; +delete_dups([]) -> + []. + +count_test_cases(Tests, Skip) -> + SendResult = fun(Me, Result) -> Me ! {no_of_cases,Result} end, + TSPid = test_server_ctrl:start_get_totals(SendResult), + Ref = erlang:monitor(process, TSPid), + add_jobs(Tests, Skip, [], []), + {Suites,NoOfCases} = count_test_cases1(length(Tests), 0, [], Ref), + erlang:demonitor(Ref), + test_server_ctrl:stop_get_totals(), + {Suites,NoOfCases}. + +count_test_cases1(0, N, Suites, _) -> + {lists:flatten(Suites), N}; +count_test_cases1(Jobs, N, Suites, Ref) -> + receive + {no_of_cases,{Ss,N1}} -> + count_test_cases1(Jobs-1, add_known(N,N1), [Ss|Suites], Ref); + {'DOWN', Ref, _, _, _} -> + {[],0} + end. + +add_known(unknown, _) -> + unknown; +add_known(_, unknown) -> + unknown; +add_known(N, N1) -> + N+N1. + +add_jobs([{TestDir,all,_}|Tests], Skip, Opt, CleanUp) -> + Name = get_name(TestDir), + case catch test_server_ctrl:add_dir_with_skip(Name, TestDir, + skiplist(TestDir,Skip)) of + {'EXIT',_} -> + CleanUp; + _ -> + wait_for_idle(), + add_jobs(Tests, Skip, Opt, CleanUp) + end; +add_jobs([{TestDir,[Suite],all}|Tests], Skip, Opt, CleanUp) when is_atom(Suite) -> + add_jobs([{TestDir,Suite,all}|Tests], Skip, Opt, CleanUp); +add_jobs([{TestDir,Suites,all}|Tests], Skip, Opt, CleanUp) when is_list(Suites) -> + Name = get_name(TestDir) ++ ".suites", + case catch test_server_ctrl:add_module_with_skip(Name, Suites, + skiplist(TestDir,Skip)) of + {'EXIT',_} -> + CleanUp; + _ -> + wait_for_idle(), + add_jobs(Tests, Skip, Opt, CleanUp) + end; +add_jobs([{TestDir,Suite,all}|Tests], Skip, Opt, CleanUp) -> + case maybe_interpret(Suite, all, Opt) of + ok -> + Name = get_name(TestDir) ++ "." ++ atom_to_list(Suite), + case catch test_server_ctrl:add_module_with_skip(Name, [Suite], + skiplist(TestDir,Skip)) of + {'EXIT',_} -> + CleanUp; + _ -> + wait_for_idle(), + add_jobs(Tests, Skip, Opt, [Suite|CleanUp]) + end; + Error -> + Error + end; +add_jobs([{TestDir,Suite,[Case]}|Tests], Skip, Opt, CleanUp) when is_atom(Case) -> + add_jobs([{TestDir,Suite,Case}|Tests], Skip, Opt, CleanUp); +add_jobs([{TestDir,Suite,Cases}|Tests], Skip, Opt, CleanUp) when is_list(Cases) -> + case maybe_interpret(Suite, Cases, Opt) of + ok -> + Name = get_name(TestDir) ++ "." ++ atom_to_list(Suite) ++ ".cases", + case catch test_server_ctrl:add_cases_with_skip(Name, Suite, Cases, + skiplist(TestDir,Skip)) of + {'EXIT',_} -> + CleanUp; + _ -> + wait_for_idle(), + add_jobs(Tests, Skip, Opt, [Suite|CleanUp]) + end; + Error -> + Error + end; +add_jobs([{TestDir,Suite,Case}|Tests], Skip, Opt, CleanUp) when is_atom(Case) -> + case maybe_interpret(Suite, Case, Opt) of + ok -> + Name = get_name(TestDir) ++ "." ++ atom_to_list(Suite) ++ "." ++ + atom_to_list(Case), + case catch test_server_ctrl:add_case_with_skip(Name, Suite, Case, + skiplist(TestDir,Skip)) of + {'EXIT',_} -> + CleanUp; + _ -> + wait_for_idle(), + add_jobs(Tests, Skip, Opt, [Suite|CleanUp]) + end; + Error -> + Error + end; +add_jobs([], _, _, CleanUp) -> + CleanUp. + +wait_for_idle() -> + ct_util:update_last_run_index(), + Notify = fun(Me) -> Me ! idle end, + case catch test_server_ctrl:idle_notify(Notify) of + {'EXIT',_} -> + error; + TSPid -> + %% so we don't hang forever if test_server dies + Ref = erlang:monitor(process, TSPid), + Result = receive + idle -> ok; + {'DOWN', Ref, _, _, _} -> error + end, + erlang:demonitor(Ref), + ct_util:update_last_run_index(), + Result + end. + +skiplist(Dir, [{Dir,all,Cmt}|Skip]) -> + %% we need to turn 'all' into list of modules since + %% test_server doesn't do skips on Dir level + Ss = filelib:wildcard(filename:join(Dir, "*_SUITE.beam")), + [{list_to_atom(filename:basename(S,".beam")),Cmt} || S <- Ss] ++ skiplist(Dir,Skip); +skiplist(Dir, [{Dir,S,Cmt}|Skip]) -> + [{S,Cmt} | skiplist(Dir, Skip)]; +skiplist(Dir, [{Dir,S,C,Cmt}|Skip]) -> + [{S,C,Cmt} | skiplist(Dir, Skip)]; +skiplist(Dir, [_|Skip]) -> + skiplist(Dir, Skip); +skiplist(_Dir, []) -> + []. + +get_name(Dir) -> + TestDir = + case filename:basename(Dir) of + "test" -> + filename:dirname(Dir); + _ -> + Dir + end, + Base = filename:basename(TestDir), + case filename:basename(filename:dirname(TestDir)) of + "" -> + Base; + TopDir -> + TopDir ++ "." ++ Base + end. + + +run_make(TestDir, Mod, UserInclude) -> + run_make(suites, TestDir, Mod, UserInclude). + +run_make(Targets, TestDir0, Mod, UserInclude) when is_list(Mod) -> + run_make(Targets, TestDir0, list_to_atom(Mod), UserInclude); + +run_make(Targets, TestDir0, Mod, UserInclude) -> + case locate_test_dir(TestDir0, Mod) of + {ok,TestDir} -> + %% send a start_make notification which may suspend + %% the process if some other node is compiling files + %% in the same directory + ct_event:sync_notify(#event{name=start_make, + node=node(), + data=TestDir}), + {ok,Cwd} = file:get_cwd(), + ok = file:set_cwd(TestDir), + TestServerInclude = get_dir(test_server, "include"), + CtInclude = get_dir(common_test, "include"), + XmerlInclude = get_dir(xmerl, "include"), + ErlFlags = UserInclude ++ [{i,TestServerInclude}, + {i,CtInclude}, + {i,XmerlInclude}, + debug_info], + Result = + if Mod == all ; Targets == helpmods -> + case (catch ct_make:all([noexec])) of + {'EXIT',_} = Failure -> + Failure; + MakeInfo -> + FileTest = fun(F, suites) -> is_suite(F); + (F, helpmods) -> not is_suite(F); + (_, _) -> true end, + Files = lists:flatmap(fun({F,out_of_date}) -> + case FileTest(F, Targets) of + true -> [F]; + false -> [] + end; + (_) -> + [] + end, MakeInfo), + (catch ct_make:files(Files, [load|ErlFlags])) + end; + true -> + (catch ct_make:files([Mod], [load|ErlFlags])) + end, + + ok = file:set_cwd(Cwd), + %% send finished_make notification + ct_event:notify(#event{name=finished_make, + node=node(), + data=TestDir}), + case Result of + {up_to_date,_} -> + ok; + {'EXIT',Reason} -> + io:format("{error,{make_crashed,~p}\n", [Reason]), + {error,{make_crashed,TestDir,Reason}}; + {error,ModInfo} -> + io:format("{error,make_failed}\n", []), + Bad = [filename:join(TestDir, M) || {M,R} <- ModInfo, + R == error], + {error,{make_failed,Bad}} + end; + {error,_} -> + io:format("{error,{invalid_directory,~p}}\n", [TestDir0]), + {error,{invalid_directory,TestDir0}} + end. + +get_dir(App, Dir) -> + filename:join(code:lib_dir(App), Dir). + +maybe_interpret(Suite, Cases, [{step,StepOpts}]) -> + %% if other suite has run before this one, check if last testcase + %% has left a "dead" trace window behind, and if so, kill it + case ct_util:get_testdata(interpret) of + {_What,kill,{TCPid,AttPid}} -> + ct_util:kill_attached(TCPid, AttPid); + _ -> + ok + end, + maybe_interpret1(Suite, Cases, StepOpts); +maybe_interpret(_, _, _) -> + ok. + +maybe_interpret1(Suite, all, StepOpts) -> + case i:ii(Suite) of + {module,_} -> + i:iaa([break]), + case get_all_testcases(Suite) of + {error,_} -> + {error,no_testcases_found}; + Cases -> + maybe_interpret2(Suite, Cases, StepOpts) + end; + error -> + {error,could_not_interpret_module} + end; +maybe_interpret1(Suite, Case, StepOpts) when is_atom(Case) -> + maybe_interpret1(Suite, [Case], StepOpts); +maybe_interpret1(Suite, Cases, StepOpts) when is_list(Cases) -> + case i:ii(Suite) of + {module,_} -> + i:iaa([break]), + maybe_interpret2(Suite, Cases, StepOpts); + error -> + {error,could_not_interpret_module} + end. + +maybe_interpret2(Suite, Cases, StepOpts) -> + set_break_on_config(Suite, StepOpts), + [i:ib(Suite, Case, 1) || Case <- Cases], + test_server_ctrl:multiply_timetraps(infinity), + WinOp = case lists:member(keep_inactive, ensure_atom(StepOpts)) of + true -> no_kill; + false -> kill + end, + ct_util:set_testdata({interpret,{{Suite,Cases},WinOp, + {undefined,undefined}}}), + ok. + +set_break_on_config(Suite, StepOpts) -> + case lists:member(config, ensure_atom(StepOpts)) of + true -> + i:ib(Suite, init_per_suite, 1), + i:ib(Suite, init_per_testcase, 2), + i:ib(Suite, end_per_testcase, 2), + i:ib(Suite, end_per_suite, 1); + false -> + ok + end. + +maybe_cleanup_interpret(Suite, [{step,_}]) -> + i:iq(Suite); +maybe_cleanup_interpret(_, _) -> + ok. + +log_ts_names(Args) -> + case lists:keysearch(spec, 1, Args) of + {value,{_,Specs}} -> + List = lists:map(fun(Name) -> + Name ++ " " + end, Specs), + ct_logs:log("Test Specification file(s)", "~s", + [lists:flatten(List)]); + _ -> + ok + end. + +merge_arguments(Args) -> + merge_arguments(Args, []). + +merge_arguments([LogDir={logdir,_}|Args], Merged) -> + merge_arguments(Args, handle_arg(replace, LogDir, Merged)); +merge_arguments([CoverFile={cover,_}|Args], Merged) -> + merge_arguments(Args, handle_arg(replace, CoverFile, Merged)); +merge_arguments([Arg={_,_}|Args], Merged) -> + merge_arguments(Args, handle_arg(merge, Arg, Merged)); +merge_arguments([], Merged) -> + Merged. + +handle_arg(replace, {Key,Elems}, [{Key,_}|Merged]) -> + [{Key,Elems}|Merged]; +handle_arg(merge, {Key,Elems}, [{Key,PrevElems}|Merged]) -> + [{Key,PrevElems++Elems}|Merged]; +handle_arg(Op, Arg, [Other|Merged]) -> + [Other|handle_arg(Op, Arg, Merged)]; +handle_arg(_,Arg,[]) -> + [Arg]. + +locate_test_dir(Dir, Suite) -> + TestDir = case ct_util:is_test_dir(Dir) of + true -> Dir; + false -> ct_util:get_testdir(Dir, Suite) + end, + case filelib:is_dir(TestDir) of + true -> {ok,TestDir}; + false -> {error,invalid} + end. + +is_suite(Mod) when is_atom(Mod) -> + is_suite(atom_to_list(Mod)); +is_suite(ModOrFile) when is_list(ModOrFile) -> + case lists:reverse(filename:basename(ModOrFile, ".erl")) of + [$E,$T,$I,$U,$S,$_|_] -> + true; + _ -> + case lists:reverse(filename:basename(ModOrFile, ".beam")) of + [$E,$T,$I,$U,$S,$_|_] -> + true; + _ -> + false + end + end. + +get_all_testcases(Suite) -> + %%! this needs to be updated to handle testcase groups later!! + case catch Suite:all() of + {'EXIT',Why} -> + {error,Why}; + {skip,_} -> + []; + Cases -> + AllCases = + lists:foldl(fun({sequence,SeqName}, All) -> + case catch Suite:sequences() of + {'EXIT',_} -> + All; + Seqs -> + case proplists:get_value(SeqName, Seqs) of + undefined -> + All; + SeqCases -> + lists:reverse(SeqCases) ++ All + end + end; + (Case,All) -> + [Case|All] + end, [], Cases), + lists:reverse(AllCases) + end. + + +%% Internal tracing support. If {ct_trace,TraceSpec} is present, the +%% TraceSpec file will be consulted and dbg used to trace function +%% calls during test run. Expected terms in TraceSpec: +%% {m,Mod} or {f,Mod,Func}. +start_trace(Args) -> + case lists:keysearch(ct_trace,1,Args) of + {value,{ct_trace,File}} -> + TraceSpec = delistify(File), + case file:consult(TraceSpec) of + {ok,Terms} -> + case catch do_trace(Terms) of + ok -> + true; + {_,Error} -> + io:format("Warning! Tracing not started. Reason: ~p~n~n", + [Error]), + false + end; + {_,Error} -> + io:format("Warning! Tracing not started. Reason: ~p~n~n", + [Error]), + false + end; + false -> + false + end. + +do_trace(Terms) -> + dbg:tracer(), + dbg:p(self(), [sos,call]), + lists:foreach(fun({m,M}) -> + case dbg:tpl(M,[{'_',[],[{return_trace}]}]) of + {error,What} -> exit({error,{tracing_failed,What}}); + _ -> ok + end; + ({f,M,F}) -> + case dbg:tpl(M,F,[{'_',[],[{return_trace}]}]) of + {error,What} -> exit({error,{tracing_failed,What}}); + _ -> ok + end; + (Huh) -> + exit({error,{unrecognized_trace_term,Huh}}) + end, Terms), + ok. + +stop_trace(true) -> + dbg:stop_clear(); +stop_trace(false) -> + ok. + +preload() -> + io:format("~nLoading Common Test and Test Server modules...~n~n"), + preload_mod([ct_logs, + ct_make, + ct_telnet, + ct, + ct_master, + ct_testspec, + ct_cover, + ct_master_event, + ct_util, + ct_event, + ct_master_logs, + ct_framework, + teln, + ct_ftp, + ct_rpc, + unix_telnet, + ct_gen_conn, + ct_line, + ct_snmp, + test_server_sup, + test_server, + test_server_ctrl, + test_server_h, + test_server_line, + test_server_node]). + +preload_mod([M|Ms]) -> + case code:is_loaded(M) of + false -> + {module,M} = code:load_file(M), + preload_mod(Ms); + _ -> + ok + end; +preload_mod([]) -> + ok. + +ensure_atom(Atom) when is_atom(Atom) -> + Atom; +ensure_atom(String) when is_list(String), is_integer(hd(String)) -> + list_to_atom(String); +ensure_atom(List) when is_list(List) -> + [ensure_atom(Item) || Item <- List]; +ensure_atom(Other) -> + Other. + diff --git a/lib/common_test/src/ct_snmp.erl b/lib/common_test/src/ct_snmp.erl new file mode 100644 index 0000000000..7ff88ad7d3 --- /dev/null +++ b/lib/common_test/src/ct_snmp.erl @@ -0,0 +1,771 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test user interface module for the OTP snmp application +%%% +%%% The purpose of this module is to make snmp configuration easier for +%%% the test case writer. Many test cases can use default values for common +%%% operations and then no snmp configuration files need to be supplied. When +%%% it is necessary to change particular configuration parameters, a subset +%%% of the relevant snmp configuration files may be passed to <code>ct_snmp</code> +%%% by means of Common Test configuration files. +%%% For more specialized configuration parameters, it is possible to place a +%%% "simple snmp configuration file" in the test suite data directory. +%%% To simplify the test suite, Common Test keeps track +%%% of some of the snmp manager information. This way the test suite doesn't +%%% have to handle as many input parameters as it would if it had to interface the +%%% OTP snmp manager directly. +%%% +%%% <p> The following snmp manager and agent parameters are configurable: </p> +%%% +%%% <pre> +%%% {snmp, +%%% %%% Manager config +%%% [{start_manager, boolean()} % Optional - default is true +%%% {users, [{user_name(), [call_back_module(), user_data()]}]}, %% Optional +%%% {usm_users, [{usm_user_name(), usm_config()}]},%% Optional - snmp v3 only +%%% % managed_agents is optional +%%% {managed_agents,[{agent_name(), [user_name(), agent_ip(), agent_port(), [agent_config()]]}]}, +%%% {max_msg_size, integer()}, % Optional - default is 484 +%%% {mgr_port, integer()}, % Optional - default is 5000 +%%% {engine _id, string()}, % Optional - default is "mgrEngine" +%%% +%%% %%% Agent config +%%% {start_agent, boolean()}, % Optional - default is false +%%% {agent_sysname, string()}, % Optional - default is "ct_test" +%%% {agent_manager_ip, manager_ip()}, % Optional - default is localhost +%%% {agent_vsns, list()}, % Optional - default is [v2] +%%% {agent_trap_udp, integer()}, % Optional - default is 5000 +%%% {agent_udp, integer()}, % Optional - default is 4000 +%%% {agent_notify_type, atom()}, % Optional - default is trap +%%% {agent_sec_type, sec_type()}, % Optional - default is none +%%% {agent_passwd, string()}, % Optional - default is "" +%%% {agent_engine_id, string()}, % Optional - default is "agentEngine" +%%% {agent_max_msg_size, string()},% Optional - default is 484 +%%% +%%% %% The following parameters represents the snmp configuration files +%%% %% context.conf, standard.conf, community.conf, vacm.conf, +%%% %% usm.conf, notify.conf, target_addr.conf and target_params.conf. +%%% %% Note all values in agent.conf can be altered by the parametes +%%% %% above. All these configuration files have default values set +%%% %% up by the snmp application. These values can be overridden by +%%% %% suppling a list of valid configuration values or a file located +%%% %% in the test suites data dir that can produce a list +%%% %% of valid configuration values if you apply file:consult/1 to the +%%% %% file. +%%% {agent_contexts, [term()] | {data_dir_file, rel_path()}}, % Optional +%%% {agent_community, [term()] | {data_dir_file, rel_path()}},% Optional +%%% {agent_sysinfo, [term()] | {data_dir_file, rel_path()}}, % Optional +%%% {agent_vacm, [term()] | {data_dir_file, rel_path()}}, % Optional +%%% {agent_usm, [term()] | {data_dir_file, rel_path()}}, % Optional +%%% {agent_notify_def, [term()] | {data_dir_file, rel_path()}},% Optional +%%% {agent_target_address_def, [term()] | {data_dir_file, rel_path()}},% Optional +%%% {agent_target_param_def, [term()] | {data_dir_file, rel_path()}},% Optional +%%% ]}. +%%% </pre> +%%% +%%% <p>The <code>MgrAgentConfName</code> parameter in the functions +%%% should be a name you allocate in your test suite using a +%%% <code>require</code> statement. +%%% Example (where <code>MgrAgentConfName = snmp_mgr_agent</code>):</p> +%%% <pre> suite() -> [{require, snmp_mgr_agent, snmp}].</pre> +%%% <p>or</p> +%%% <pre> ct:require(snmp_mgr_agent, snmp).</pre> +%%% +%%% <p> Note that Usm users are needed for snmp v3 configuration and are +%%% not to be confused with users.</p> +%%% +%%% <p> Snmp traps, inform and report messages are handled by the +%%% user callback module. For more information about this see +%%% the snmp application. </p> +%%% <p> Note: It is recommended to use the .hrl-files created by the +%%% Erlang/OTP mib-compiler to define the oids. +%%% Example for the getting the erlang node name from the erlNodeTable +%%% in the OTP-MIB:</p> +%%% <pre>Oid = ?erlNodeEntry ++ [?erlNodeName, 1] </pre> +%%% +%%% <p>It is also possible to set values for snmp application configuration +%%% parameters, such as <code>config</code>, <code>server</code>, +%%% <code>net_if</code>, etc (see the "Configuring the application" chapter in +%%% the OTP snmp User's Guide for a list of valid parameters and types). This is +%%% done by defining a configuration data variable on the following form:</p> +%%% <pre> +%%% {snmp_app, [{manager, [snmp_app_manager_params()]}, +%%% {agent, [snmp_app_agent_params()]}]}.</pre> +%%% +%%% <p>A name for the data needs to be allocated in the suite using +%%% <code>require</code> (see example above), and this name passed as +%%% the <code>SnmpAppConfName</code> argument to <code>start/3</code>. +%%% <code>ct_snmp</code> specifies default values for some snmp application +%%% configuration parameters (such as <code>{verbosity,trace}</code> for the +%%% <code>config</code> parameter). This set of defaults will be +%%% merged with the parameters specified by the user, and user values +%%% override <code>ct_snmp</code> defaults.</p> + +-module(ct_snmp). + +%%% Common Types +%%% @type agent_ip() = ip() +%%% @type manager_ip() = ip() +%%% @type agent_name() = atom() +%%% @type ip() = string() | {integer(), integer(), +%%% integer(), integer()} +%%% @type agent_port() = integer() +%%% @type agent_config() = {Item, Value} +%%% @type user_name() = atom() +%%% @type usm_user_name() = string() +%%% @type usm_config() = string() +%%% @type call_back_module() = atom() +%%% @type user_data() = term() +%%% @type oids() = [oid()] +%%% @type oid() = [byte()] +%%% @type snmpreply() = {error_status(), error_index(), varbinds()} +%%% @type error_status() = noError | atom() +%%% @type error_index() = integer() +%%% @type varbinds() = [varbind()] +%%% @type varbind() = term() +%%% @type value_type() = o ('OBJECT IDENTIFIER') | i ('INTEGER') | +%%% u ('Unsigned32') | g ('Unsigned32') | s ('OCTET STRING') +%%% @type varsandvals() = [var_and_val()] +%%% @type var_and_val() = {oid(), value_type(), value()} +%%% @type sec_type() = none | minimum | semi +%%% @type rel_path() = string() +%%% @type snmp_app_manager_params() = term() +%%% @type snmp_app_agent_params() = term() + + +-include("snmp_types.hrl"). +-include("inet.hrl"). +-include("ct.hrl"). + +%%% API +-export([start/2, start/3, stop/1, get_values/3, get_next_values/3, set_values/4, + set_info/1, register_users/2, register_agents/2, register_usm_users/2, + unregister_users/1, unregister_agents/1, update_usm_users/2, + load_mibs/1]). + +%% Manager values +-define(CT_SNMP_LOG_FILE, "ct_snmp_set.log"). +-define(MGR_PORT, 5000). +-define(MAX_MSG_SIZE, 484). +-define(ENGINE_ID, "mgrEngine"). + +%% Agent values +-define(AGENT_ENGINE_ID, "agentEngine"). +-define(TRAP_UDP, 5000). +-define(AGENT_UDP, 4000). +-define(CONF_FILE_VER, [v2]). +-define(AGENT_MAX_MSG_SIZE, 484). +-define(AGENT_NOTIFY_TYPE, trap). +-define(AGENT_SEC_TYPE, none). +-define(AGENT_PASSWD, ""). +%%%========================================================================= +%%% API +%%%========================================================================= + +%%%----------------------------------------------------------------- +%%% @spec start(Config, MgrAgentConfName) -> ok +%%% @equiv start(Config, MgrAgentConfName, undefined) +start(Config, MgrAgentConfName) -> + start(Config, MgrAgentConfName, undefined). + +%%% @spec start(Config, MgrAgentConfName, SnmpAppConfName) -> ok +%%% Config = [{Key, Value}] +%%% Key = atom() +%%% Value = term() +%%% MgrAgentConfName = atom() +%%% SnmpConfName = atom() +%%% +%%% @doc Starts an snmp manager and/or agent. In the manager case, +%%% registrations of users and agents as specified by the configuration +%%% <code>MgrAgentConfName</code> will be performed. When using snmp +%%% v3 also so called usm users will be registered. Note that users, +%%% usm_users and managed agents may also be registered at a later time +%%% using ct_snmp:register_users/2, ct_snmp:register_agents/2, and +%%% ct_snmp:register_usm_users/2. The agent started will be +%%% called <code>snmp_master_agent</code>. Use ct_snmp:load_mibs/1 to load +%%% mibs into the agent. With <code>SnmpAppConfName</code> it's possible +%%% to configure the snmp application with parameters such as <code>config</code>, +%%% <code>mibs</code>, <code>net_if</code>, etc. The values will be merged +%%% with (and possibly override) default values set by <code>ct_snmp</code>. +start(Config, MgrAgentConfName, SnmpAppConfName) -> + StartManager= ct:get_config({MgrAgentConfName, start_manager}, true), + StartAgent = ct:get_config({MgrAgentConfName, start_agent}, false), + + SysName = ct:get_config({MgrAgentConfName, agent_sysname}, "ct_test"), + {ok, HostName} = inet:gethostname(), + {ok, Addr} = inet:getaddr(HostName, inet), + IP = tuple_to_list(Addr), + AgentManagerIP = ct:get_config({MgrAgentConfName, agent_manager_ip}, IP), + + prepare_snmp_env(), + setup_agent(StartAgent, MgrAgentConfName, SnmpAppConfName, + Config, SysName, AgentManagerIP, IP), + setup_manager(StartManager, MgrAgentConfName, SnmpAppConfName, + Config, AgentManagerIP), + application:start(snmp), + + manager_register(StartManager, MgrAgentConfName). + +%%% @spec stop(Config) -> ok +%%% Config = [{Key, Value}] +%%% Key = atom() +%%% Value = term() +%%% +%%% @doc Stops the snmp manager and/or agent removes all files created. +stop(Config) -> + PrivDir = ?config(priv_dir, Config), + application:stop(snmp), + application:stop(mnesia), + MgrDir = filename:join(PrivDir,"mgr"), + ConfDir = filename:join(PrivDir, "conf"), + DbDir = filename:join(PrivDir,"db"), + catch del_dir(MgrDir), + catch del_dir(ConfDir), + catch del_dir(DbDir). + + +%%% @spec get_values(Agent, Oids, MgrAgentConfName) -> SnmpReply +%%% +%%% Agent = agent_name() +%%% Oids = oids() +%%% MgrAgentConfName = atom() +%%% SnmpReply = snmpreply() +%%% +%%% @doc Issues a synchronous snmp get request. +get_values(Agent, Oids, MgrAgentConfName) -> + [Uid, AgentIp, AgentUdpPort | _] = + agent_conf(Agent, MgrAgentConfName), + {ok, SnmpReply, _} = + snmpm:g(Uid, AgentIp, AgentUdpPort, Oids), + SnmpReply. + +%%% @spec get_next_values(Agent, Oids, MgrAgentConfName) -> SnmpReply +%%% +%%% Agent = agent_name() +%%% Oids = oids() +%%% MgrAgentConfName = atom() +%%% SnmpReply = snmpreply() +%%% +%%% @doc Issues a synchronous snmp get next request. +get_next_values(Agent, Oids, MgrAgentConfName) -> + [Uid, AgentIp, AgentUdpPort | _] = + agent_conf(Agent, MgrAgentConfName), + {ok, SnmpReply, _} = + snmpm:gn(Uid, AgentIp, AgentUdpPort, Oids), + SnmpReply. + +%%% @spec set_values(Agent, VarsAndVals, MgrAgentConfName, Config) -> SnmpReply +%%% +%%% Agent = agent_name() +%%% Oids = oids() +%%% MgrAgentConfName = atom() +%%% Config = [{Key, Value}] +%%% SnmpReply = snmpreply() +%%% +%%% @doc Issues a synchronous snmp set request. +set_values(Agent, VarsAndVals, MgrAgentConfName, Config) -> + PrivDir = ?config(priv_dir, Config), + [Uid, AgentIp, AgentUdpPort | _] = + agent_conf(Agent, MgrAgentConfName), + Oids = lists:map(fun({Oid, _, _}) -> Oid end, VarsAndVals), + {ok, SnmpGetReply, _} = + snmpm:g(Uid, AgentIp, AgentUdpPort, Oids), + {ok, SnmpSetReply, _} = + snmpm:s(Uid, AgentIp, AgentUdpPort, VarsAndVals), + case SnmpSetReply of + {noError, 0, _} when PrivDir /= false -> + log(PrivDir, Agent, SnmpGetReply, VarsAndVals); + _ -> + set_failed_or_user_did_not_want_to_log + end, + SnmpSetReply. + +%%% @spec set_info(Config) -> [{Agent, OldVarsAndVals, NewVarsAndVals}] +%%% +%%% Config = [{Key, Value}] +%%% Agent = agent_name() +%%% OldVarsAndVals = varsandvals() +%%% NewVarsAndVals = varsandvals() +%%% +%%% @doc Returns a list of all successful set requests performed in +%%% the test case in reverse order. The list contains the involved +%%% user and agent, the value prior to the set and the new value. This +%%% is intended to facilitate the clean up in the end_per_testcase +%%% function i.e. the undoing of the set requests and its possible +%%% side-effects. +set_info(Config) -> + PrivDir = ?config(priv_dir, Config), + SetLogFile = filename:join(PrivDir, ?CT_SNMP_LOG_FILE), + case file:consult(SetLogFile) of + {ok, SetInfo} -> + file:delete(SetLogFile), + lists:reverse(SetInfo); + _ -> + [] + end. + +%%% @spec register_users(MgrAgentConfName, Users) -> ok | {error, Reason} +%%% +%%% MgrAgentConfName = atom() +%%% Users = [user()] +%%% Reason = term() +%%% +%%% @doc Register the manager entity (=user) responsible for specific agent(s). +%%% Corresponds to making an entry in users.conf +register_users(MgrAgentConfName, Users) -> + {snmp, SnmpVals} = ct:get_config(MgrAgentConfName), + NewSnmpVals = lists:keyreplace(users, 1, SnmpVals, {users, Users}), + ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}), + setup_users(Users). + +%%% @spec register_agents(MgrAgentConfName, ManagedAgents) -> ok | {error, Reason} +%%% +%%% MgrAgentConfName = atom() +%%% ManagedAgents = [agent()] +%%% Reason = term() +%%% +%%% @doc Explicitly instruct the manager to handle this agent. +%%% Corresponds to making an entry in agents.conf +register_agents(MgrAgentConfName, ManagedAgents) -> + {snmp, SnmpVals} = ct:get_config(MgrAgentConfName), + NewSnmpVals = lists:keyreplace(managed_agents, 1, SnmpVals, + {managed_agents, ManagedAgents}), + ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}), + setup_managed_agents(ManagedAgents). + +%%% @spec register_usm_users(MgrAgentConfName, UsmUsers) -> ok | {error, Reason} +%%% +%%% MgrAgentConfName = atom() +%%% UsmUsers = [usm_user()] +%%% Reason = term() +%%% +%%% @doc Explicitly instruct the manager to handle this USM user. +%%% Corresponds to making an entry in usm.conf +register_usm_users(MgrAgentConfName, UsmUsers) -> + {snmp, SnmpVals} = ct:get_config(MgrAgentConfName), + NewSnmpVals = lists:keyreplace(users, 1, SnmpVals, {usm_users, UsmUsers}), + ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}), + EngineID = ct:get_config({MgrAgentConfName, engine_id}, ?ENGINE_ID), + setup_usm_users(UsmUsers, EngineID). + +%%% @spec unregister_users(MgrAgentConfName) -> ok | {error, Reason} +%%% +%%% MgrAgentConfName = atom() +%%% Reason = term() +%%% +%%% @doc Removes information added when calling register_users/2. +unregister_users(MgrAgentConfName) -> + Users = lists:map(fun({UserName, _}) -> UserName end, + ct:get_config({MgrAgentConfName, users})), + {snmp, SnmpVals} = ct:get_config(MgrAgentConfName), + NewSnmpVals = lists:keyreplace(users, 1, SnmpVals, {users, []}), + ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}), + takedown_users(Users). + +%%% @spec unregister_agents(MgrAgentConfName) -> ok | {error, Reason} +%%% +%%% MgrAgentConfName = atom() +%%% Reason = term() +%%% +%%% @doc Removes information added when calling register_agents/2. +unregister_agents(MgrAgentConfName) -> + ManagedAgents = lists:map(fun({_, [Uid, AgentIP, AgentPort, _]}) -> + {Uid, AgentIP, AgentPort} + end, + ct:get_config({MgrAgentConfName, managed_agents})), + {snmp, SnmpVals} = ct:get_config(MgrAgentConfName), + NewSnmpVals = lists:keyreplace(managed_agents, 1, SnmpVals, + {managed_agents, []}), + ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}), + takedown_managed_agents(ManagedAgents). + + +%%% @spec update_usm_users(MgrAgentConfName, UsmUsers) -> ok | {error, Reason} +%%% +%%% MgrAgentConfName = atom() +%%% UsmUsers = usm_users() +%%% Reason = term() +%%% +%%% @doc Alters information added when calling register_usm_users/2. +update_usm_users(MgrAgentConfName, UsmUsers) -> + + {snmp, SnmpVals} = ct:get_config(MgrAgentConfName), + NewSnmpVals = lists:keyreplace(usm_users, 1, SnmpVals, + {usm_users, UsmUsers}), + ct_util:update_config(MgrAgentConfName, {snmp, NewSnmpVals}), + EngineID = ct:get_config({MgrAgentConfName, engine_id}, ?ENGINE_ID), + do_update_usm_users(UsmUsers, EngineID). + +%%% @spec load_mibs(Mibs) -> ok | {error, Reason} +%%% +%%% Mibs = [MibName] +%%% MibName = string() +%%% Reason = term() +%%% +%%% @doc Load the mibs into the agent 'snmp_master_agent'. +load_mibs(Mibs) -> + snmpa:load_mibs(snmp_master_agent, Mibs). + + +%%%======================================================================== +%%% Internal functions +%%%======================================================================== +prepare_snmp_env() -> + %% To make sure application:set_env is not overwritten by any + %% app-file settings. + application:load(snmp), + + %% Fix for older versions of snmp where there are some + %% inappropriate default values for alway starting an + %% agent. + application:unset_env(snmp, agent). +%%%--------------------------------------------------------------------------- +setup_manager(false, _, _, _, _) -> + ok; +setup_manager(true, MgrConfName, SnmpConfName, Config, IP) -> + PrivDir = ?config(priv_dir, Config), + MaxMsgSize = ct:get_config({MgrConfName,max_msg_size}, ?MAX_MSG_SIZE), + Port = ct:get_config({MgrConfName,mgr_port}, ?MGR_PORT), + EngineID = ct:get_config({MgrConfName,engine_id}, ?ENGINE_ID), + MgrDir = filename:join(PrivDir,"mgr"), + %%% Users, Agents and Usms are in test suites register after the + %%% snmp application is started. + Users = [], + Agents = [], + Usms = [], + file:make_dir(MgrDir), + + snmp_config:write_manager_snmp_files(MgrDir, IP, Port, MaxMsgSize, + EngineID, Users, Agents, Usms), + SnmpEnv = merge_snmp_conf([{config, [{dir, MgrDir},{db_dir, MgrDir}, + {verbosity, trace}]}, + {server, [{verbosity, trace}]}, + {net_if, [{verbosity, trace}]}, + {versions, [v1, v2, v3]}], + ct:get_config({SnmpConfName,manager})), + application:set_env(snmp, manager, SnmpEnv). +%%%--------------------------------------------------------------------------- +setup_agent(false,_, _, _, _, _, _) -> + ok; +setup_agent(true, AgentConfName, SnmpConfName, + Config, SysName, ManagerIP, AgentIP) -> + application:start(mnesia), + PrivDir = ?config(priv_dir, Config), + Vsns = ct:get_config({AgentConfName, agent_vsns}, ?CONF_FILE_VER), + TrapUdp = ct:get_config({AgentConfName, agent_trap_udp}, ?TRAP_UDP), + AgentUdp = ct:get_config({AgentConfName, agent_udp}, ?AGENT_UDP), + NotifType = ct:get_config({AgentConfName, agent_notify_type}, + ?AGENT_NOTIFY_TYPE), + SecType = ct:get_config({AgentConfName, agent_sec_type}, ?AGENT_SEC_TYPE), + Passwd = ct:get_config({AgentConfName, agent_passwd}, ?AGENT_PASSWD), + AgentEngineID = ct:get_config({AgentConfName, agent_engine_id}, + ?AGENT_ENGINE_ID), + AgentMaxMsgSize = ct:get_config({AgentConfName, agent_max_msg_size}, + ?MAX_MSG_SIZE), + + ConfDir = filename:join(PrivDir, "conf"), + DbDir = filename:join(PrivDir,"db"), + file:make_dir(ConfDir), + file:make_dir(DbDir), + snmp_config:write_agent_snmp_files(ConfDir, Vsns, ManagerIP, TrapUdp, + AgentIP, AgentUdp, SysName, + atom_to_list(NotifType), + SecType, Passwd, AgentEngineID, + AgentMaxMsgSize), + + override_default_configuration(Config, AgentConfName), + + SnmpEnv = merge_snmp_conf([{db_dir, DbDir}, + {config, [{dir, ConfDir}, + {verbosity, trace}]}, + {agent_type, master}, + {agent_verbosity, trace}, + {net_if, [{verbosity, trace}]}], + ct:get_config({SnmpConfName,agent})), + application:set_env(snmp, agent, SnmpEnv). +%%%--------------------------------------------------------------------------- +merge_snmp_conf(Defaults, undefined) -> + Defaults; +merge_snmp_conf([Def={Key,DefList=[P|_]}|DefParams], UserParams) when is_tuple(P) -> + case lists:keysearch(Key, 1, UserParams) of + false -> + [Def | merge_snmp_conf(DefParams, UserParams)]; + {value,{Key,UserList}} -> + DefList1 = [{SubKey,Val} || {SubKey,Val} <- DefList, + lists:keysearch(SubKey, 1, UserList) == false], + [{Key,DefList1++UserList} | merge_snmp_conf(DefParams, + lists:keydelete(Key, 1, UserParams))] + end; +merge_snmp_conf([Def={Key,_}|DefParams], UserParams) -> + case lists:keysearch(Key, 1, UserParams) of + false -> + [Def | merge_snmp_conf(DefParams, UserParams)]; + {value,_} -> + merge_snmp_conf(DefParams, UserParams) + end; +merge_snmp_conf([], UserParams) -> + UserParams. + + +%%%--------------------------------------------------------------------------- +manager_register(false, _) -> + ok; +manager_register(true, MgrAgentConfName) -> + Agents = ct:get_config({MgrAgentConfName, managed_agents}, []), + Users = ct:get_config({MgrAgentConfName, users}, []), + UsmUsers = ct:get_config({MgrAgentConfName, usm_users}, []), + EngineID = ct:get_config({MgrAgentConfName, engine_id}, ?ENGINE_ID), + + setup_usm_users(UsmUsers, EngineID), + setup_users(Users), + setup_managed_agents(Agents). + +%%%--------------------------------------------------------------------------- +setup_users(Users) -> + lists:foreach(fun({Id, [Module, Data]}) -> + snmpm:register_user(Id, Module, Data) + end, Users). +%%%--------------------------------------------------------------------------- +setup_managed_agents([]) -> + ok; + +setup_managed_agents([{_, [Uid, AgentIp, AgentUdpPort, AgentConf]} | + Rest]) -> + NewAgentIp = case AgentIp of + IpTuple when is_tuple(IpTuple) -> + IpTuple; + HostName when is_list(HostName) -> + {ok,Hostent} = inet:gethostbyname(HostName), + [IpTuple|_] = Hostent#hostent.h_addr_list, + IpTuple + end, + ok = snmpm:register_agent(Uid, NewAgentIp, AgentUdpPort), + lists:foreach(fun({Item, Val}) -> + snmpm:update_agent_info(Uid, NewAgentIp, + AgentUdpPort, Item, Val) + end, AgentConf), + setup_managed_agents(Rest). +%%%--------------------------------------------------------------------------- +setup_usm_users(UsmUsers, EngineID)-> + lists:foreach(fun({UsmUser, Conf}) -> + snmpm:register_usm_user(EngineID, UsmUser, Conf) + end, UsmUsers). +%%%--------------------------------------------------------------------------- +takedown_users(Users) -> + lists:foreach(fun({Id}) -> + snmpm:unregister_user(Id) + end, Users). +%%%--------------------------------------------------------------------------- +takedown_managed_agents([{Uid, AgentIp, AgentUdpPort} | + Rest]) -> + NewAgentIp = case AgentIp of + IpTuple when is_tuple(IpTuple) -> + IpTuple; + HostName when is_list(HostName) -> + {ok,Hostent} = inet:gethostbyname(HostName), + [IpTuple|_] = Hostent#hostent.h_addr_list, + IpTuple + end, + ok = snmpm:unregister_agent(Uid, NewAgentIp, AgentUdpPort), + takedown_managed_agents(Rest); + +takedown_managed_agents([]) -> + ok. +%%%--------------------------------------------------------------------------- +do_update_usm_users(UsmUsers, EngineID) -> + lists:foreach(fun({UsmUser, {Item, Val}}) -> + snmpm:update_usm_user_info(EngineID, UsmUser, + Item, Val) + end, UsmUsers). +%%%--------------------------------------------------------------------------- +log(PrivDir, Agent, {_, _, Varbinds}, NewVarsAndVals) -> + + Fun = fun(#varbind{oid = Oid, variabletype = Type, value = Value}) -> + {Oid, Type, Value} + end, + OldVarsAndVals = lists:map(Fun, Varbinds), + + File = filename:join(PrivDir, ?CT_SNMP_LOG_FILE), + {ok, Fd} = file:open(File, [write, append]), + io:format(Fd, "~p.~n", [{Agent, OldVarsAndVals, NewVarsAndVals}]), + file:close(Fd), + ok. +%%%--------------------------------------------------------------------------- +del_dir(Dir) -> + {ok, Files} = file:list_dir(Dir), + FullPathFiles = lists:map(fun(File) -> filename:join(Dir, File) end, + Files), + lists:foreach(fun file:delete/1, FullPathFiles), + file:del_dir(Dir), + ok. +%%%--------------------------------------------------------------------------- +agent_conf(Agent, MgrAgentConfName) -> + Agents = ct:get_config({MgrAgentConfName, managed_agents}), + case lists:keysearch(Agent, 1, Agents) of + {value, {Agent, AgentConf}} -> + AgentConf; + _ -> + exit({error, {unknown_agent, Agent, Agents}}) + end. +%%%--------------------------------------------------------------------------- +override_default_configuration(Config, MgrAgentConfName) -> + override_contexts(Config, + ct:get_config({MgrAgentConfName, agent_contexts}, undefined)), + override_community(Config, + ct:get_config({MgrAgentConfName, agent_community}, undefined)), + override_sysinfo(Config, + ct:get_config({MgrAgentConfName, agent_sysinfo}, undefined)), + override_vacm(Config, + ct:get_config({MgrAgentConfName, agent_vacm}, undefined)), + override_usm(Config, + ct:get_config({MgrAgentConfName, agent_usm}, undefined)), + override_notify(Config, + ct:get_config({MgrAgentConfName, agent_notify_def}, undefined)), + override_target_address(Config, + ct:get_config({MgrAgentConfName, + agent_target_address_def}, + undefined)), + override_target_params(Config, + ct:get_config({MgrAgentConfName, agent_target_param_def}, + undefined)). + +%%%--------------------------------------------------------------------------- +override_contexts(_, undefined) -> + ok; + +override_contexts(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, ContextInfo} = file:consult(FullPathFile), + override_contexts(Config, ContextInfo); + +override_contexts(Config, Contexts) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"context.conf"), + file:delete(File), + snmp_config:write_agent_context_config(Dir, "", Contexts). + +%%%--------------------------------------------------------------------------- +override_sysinfo(_, undefined) -> + ok; + +override_sysinfo(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, SysInfo} = file:consult(FullPathFile), + override_sysinfo(Config, SysInfo); + +override_sysinfo(Config, SysInfo) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"standard.conf"), + file:delete(File), + snmp_config:write_agent_standard_config(Dir, "", SysInfo). + +%%%--------------------------------------------------------------------------- +override_target_address(_, undefined) -> + ok; +override_target_address(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, TargetAddressConf} = file:consult(FullPathFile), + override_target_address(Config, TargetAddressConf); + +override_target_address(Config, TargetAddressConf) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"target_addr.conf"), + file:delete(File), + snmp_config:write_agent_target_addr_config(Dir, "", TargetAddressConf). + + +%%%--------------------------------------------------------------------------- +override_target_params(_, undefined) -> + ok; +override_target_params(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, TargetParamsConf} = file:consult(FullPathFile), + override_target_params(Config, TargetParamsConf); + +override_target_params(Config, TargetParamsConf) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"target_params.conf"), + file:delete(File), + snmp_config:write_agent_target_params_config(Dir, "", TargetParamsConf). + +%%%--------------------------------------------------------------------------- +override_notify(_, undefined) -> + ok; +override_notify(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, NotifyConf} = file:consult(FullPathFile), + override_notify(Config, NotifyConf); + +override_notify(Config, NotifyConf) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"notify.conf"), + file:delete(File), + snmp_config:write_agent_notify_config(Dir, "", NotifyConf). + +%%%--------------------------------------------------------------------------- +override_usm(_, undefined) -> + ok; +override_usm(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, UsmConf} = file:consult(FullPathFile), + override_usm(Config, UsmConf); + +override_usm(Config, UsmConf) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"usm.conf"), + file:delete(File), + snmp_config:write_agent_usm_config(Dir, "", UsmConf). + +%%%-------------------------------------------------------------------------- +override_community(_, undefined) -> + ok; +override_community(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, CommunityConf} = file:consult(FullPathFile), + override_community(Config, CommunityConf); + +override_community(Config, CommunityConf) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"community.conf"), + file:delete(File), + snmp_config:write_agent_community_config(Dir, "", CommunityConf). + +%%%--------------------------------------------------------------------------- + +override_vacm(_, undefined) -> + ok; +override_vacm(Config, {data_dir_file, File}) -> + Dir = ?config(data_dir, Config), + FullPathFile = filename:join(Dir, File), + {ok, VacmConf} = file:consult(FullPathFile), + override_vacm(Config, VacmConf); + +override_vacm(Config, VacmConf) -> + Dir = ?config(priv_dir, Config), + File = filename:join(Dir,"vacm.conf"), + file:delete(File), + snmp_config:write_agent_vacm_config(Dir, "", VacmConf). diff --git a/lib/common_test/src/ct_ssh.erl b/lib/common_test/src/ct_ssh.erl new file mode 100644 index 0000000000..f2b25b1fcd --- /dev/null +++ b/lib/common_test/src/ct_ssh.erl @@ -0,0 +1,1346 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc SSH/SFTP client module. +%%% +%%% <p>ct_ssh uses the OTP ssh application and more detailed information +%%% about e.g. functions, types and options can be found in the +%%% documentation for this application.</p> +%%% +%%% <p>The <code>Server</code> argument in the SFTP functions should +%%% only be used for SFTP sessions that have been started on existing +%%% SSH connections (i.e. when the original connection type is +%%% <code>ssh</code>). Whenever the connection type is +%%% <code>sftp</code>, use the SSH connection reference only.</p> +%%% +%%% <p>The following options are valid for specifying an SSH/SFTP +%%% connection (i.e. may be used as config elements):</p> +%%% +%%% <pre> +%%% +%%% [{ConnType, Addr}, +%%% {port, Port}, +%%% {user, UserName} +%%% {password, Pwd} +%%% {user_dir, String} +%%% {public_key_alg, PubKeyAlg} +%%% {connect_timeout, Timeout} +%%% {key_cb, KeyCallbackMod}] +%%% </pre> +%%% +%%% <p><code>ConnType = ssh | sftp</code>.</p> +%%% <p>Please see ssh(3) for other types.</p> +%%% +%%% <p>All timeout parameters in ct_ssh functions are values in +%%% milliseconds.</p> +%%% +%%% @type connection() = handle() | ct:target_name() +%%% @type handle() = ct_gen_conn:handle(). Handle for a specific +%%% SSH/SFTP connection. +%%% @type ssh_sftp_return() = term(). A return value from an ssh_sftp function. + +-module(ct_ssh). + +%% SSH Functions +-export([connect/1, connect/2, connect/3, + disconnect/1, + session_open/1, session_open/2, + session_close/2, + send/3, send/4, send/5, + receive_response/2, receive_response/3, receive_response/4, + send_and_receive/3, send_and_receive/4, send_and_receive/5, + send_and_receive/6, + exec/2, exec/3, exec/4, + subsystem/3, subsystem/4]). + +%% STFP Functions +-export([sftp_connect/1, + + read_file/2, write_file/3, list_dir/2, open/3, opendir/2, + close/2, read/3, pread/4, aread/3, apread/4, write/3, + pwrite/4, awrite/3, apwrite/4, position/3, read_file_info/2, + get_file_info/2, read_link_info/2, write_file_info/3, + read_link/2, make_symlink/3, rename/3, delete/2, make_dir/2, + del_dir/2, + + read_file/3, write_file/4, list_dir/3, open/4, opendir/3, + close/3, read/4, pread/5, aread/4, apread/5, write/4, + pwrite/5, awrite/4, apwrite/5, position/4, read_file_info/3, + get_file_info/3, read_link_info/3, write_file_info/4, + read_link/3, make_symlink/4, rename/4, delete/3, make_dir/3, + del_dir/3]). + +%% Callbacks +-export([init/3, handle_msg/2, reconnect/2, terminate/2, close/1]). + +-define(DEFAULT_TIMEOUT, 10000). + +-record(state, {ssh_ref, conn_type, target}). + + +%%%----------------------------------------------------------------- +%%%------------------------ SSH COMMANDS --------------------------- + +%%%----------------------------------------------------------------- +%%% @spec connect(KeyOrName) -> {ok,Handle} | {error,Reason} +%%% @equiv connect(KeyOrName,host,[]) +connect(KeyOrName) -> + connect(KeyOrName, host). + +%%%----------------------------------------------------------------- +%%% @spec connect(KeyOrName,ConnType) -> {ok,Handle} | {error,Reason} +%%% @equiv connect(KeyOrName,ConnType,[]) +connect(KeyOrName, ConnType) when is_atom(ConnType) -> + connect(KeyOrName, ConnType, []); + +%%%----------------------------------------------------------------- +%%% @spec connect(KeyOrName,ExtraOpts) -> {ok,Handle} | {error,Reason} +%%% @equiv connect(KeyOrName,host,ExtraOpts) +connect(KeyOrName, ExtraOpts) when is_list(ExtraOpts) -> + connect(KeyOrName, host, ExtraOpts). + +%%%----------------------------------------------------------------- +%%% @spec connect(KeyOrName,ConnType,ExtraOpts) -> +%%% {ok,Handle} | {error,Reason} +%%% KeyOrName = Key | Name +%%% Key = atom() +%%% Name = ct:target_name() +%%% ConnType = ssh | sftp | host +%%% ExtraOpts = ssh_connect_options() +%%% Handle = handle() +%%% Reason = term() +%%% +%%% @doc Open an SSH or SFTP connection using the information +%%% associated with <code>KeyOrName</code>. +%%% +%%% <p>If <code>Name</code> (an alias name for <code>Key</code>), +%%% is used to identify the connection, this name may +%%% be used as connection reference for subsequent calls. +%%% It's only possible to have one open connection at a time +%%% associated with <code>Name</code>. If <code>Key</code> is +%%% used, the returned handle must be used for subsequent calls +%%% (multiple connections may be opened using the config +%%% data specified by <code>Key</code>).</p> +%%% +%%% <p><code>ConnType</code> will always override the type +%%% specified in the address tuple in the configuration data (and +%%% in <code>ExtraOpts</code>). So it is possible to for example +%%% open an sftp connection directly using data originally +%%% specifying an ssh connection. The value <code>host</code> +%%% means the connection type specified by the host option +%%% (either in the configuration data or in <code>ExtraOpts</code>) +%%% will be used.</p> +%%% +%%% <p><code>ExtraOpts</code> (optional) are extra SSH options +%%% to be added to the config data for <code>KeyOrName</code>. +%%% The extra options will override any existing options with the +%%% same key in the config data. For details on valid SSH +%%% options, see the documentation for the OTP ssh application.</p> +connect(KeyOrName, ConnType, ExtraOpts) -> + case ct:get_config(KeyOrName) of + undefined -> + log(heading(connect,KeyOrName), "Failed: ~p\n", + [{not_available,KeyOrName}]), + {error,{not_available,KeyOrName}}; + SSHData -> + AllOpts = ExtraOpts++SSHData, + {ConnType1,Addr,AllOpts1} = + case ConnType of + host -> + case proplists:get_value(ssh, AllOpts) of + undefined -> + case proplists:get_value(sftp, AllOpts) of + undefined -> + log(heading(connect,KeyOrName), + "No host information specified!\n",[]); + SFTPAddr -> + {sftp,SFTPAddr,AllOpts} + end; + SSHAddr -> + {ssh,SSHAddr,AllOpts} + end; + _ -> + case proplists:get_value(ConnType, AllOpts) of + undefined when ConnType == ssh -> + case proplists:get_value(sftp, AllOpts) of + undefined -> + {ssh,undefined,AllOpts}; + SFTPAddr -> + log(heading(connect,KeyOrName), + "Note: Opening ssh connection to sftp host.\n", + []), + {ssh,SFTPAddr, + [{ssh,SFTPAddr}|proplists:delete(sftp, AllOpts)]} + end; + undefined when ConnType == sftp -> + case proplists:get_value(ssh, AllOpts) of + undefined -> + {sftp,undefined,AllOpts}; + SSHAddr -> + log(heading(connect,KeyOrName), + "Note: Opening sftp connection to ssh host.\n", + []), + {sftp,SSHAddr, + [{sftp,SSHAddr}|proplists:delete(ssh, AllOpts)]} + end; + SSHorSFTPAddr -> + {ConnType,SSHorSFTPAddr,AllOpts} + end + end, + case {Addr,proplists:get_value(port, AllOpts1)} of + {undefined,_} -> + log(heading(connect,KeyOrName), "Failed: ~p\n", + [{not_available,{KeyOrName,ConnType1}}]), + {error,{not_available,{KeyOrName,ConnType1}}}; + {_,undefined} -> + log(heading(connect,KeyOrName), + "Opening ~w connection to ~p:22\n", + [ConnType1,Addr]), + ct_gen_conn:start(KeyOrName, {ConnType1,Addr,22}, + AllOpts1, ?MODULE); + {_,Port} -> + log(heading(connect,KeyOrName), + "Opening ~w connection to ~p:~w\n", + [ConnType1,Addr,Port]), + ct_gen_conn:start(KeyOrName, {ConnType1,Addr,Port}, + AllOpts1, ?MODULE) + end + end. + +%%%----------------------------------------------------------------- +%%% @spec disconnect(SSH) -> ok | {error,Reason} +%%% SSH = connection() +%%% Reason = term() +%%% +%%% @doc Close an SSH/SFTP connection. +disconnect(SSH) -> + case get_handle(SSH) of + {ok,Pid} -> + log(heading(disconnect,SSH), "Handle: ~p", [Pid]), + case ct_gen_conn:stop(Pid) of + {error,{process_down,Pid,noproc}} -> + {error,already_closed}; + Result -> + Result + end; + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec session_open(SSH) -> {ok,ChannelId} | {error, Reason} +%%% @equiv session_open(SSH,DefaultTimeout) +session_open(SSH) -> + call(SSH, {session_open,?DEFAULT_TIMEOUT}). + +%%%----------------------------------------------------------------- +%%% @spec session_open(SSH,Timeout) -> {ok,ChannelId} | {error, Reason} +%%% SSH = connection() +%%% Timeout = integer() +%%% ChannelId = integer() +%%% Reason = term() +%%% +%%% @doc Opens a channel for an SSH session. +session_open(SSH, Timeout) -> + call(SSH, {session_open,Timeout}). + +%%%----------------------------------------------------------------- +%%% @spec session_close(SSH,ChannelId) -> ok | {error, Reason} +%%% SSH = connection() +%%% ChannelId = integer() +%%% Reason = term() +%%% +%%% @doc Closes an SSH session channel. +session_close(SSH, ChannelId) -> + call(SSH, {session_close,ChannelId}). + +%%%----------------------------------------------------------------- +%%% @spec exec(SSH,Command) -> {ok,Data} | {error,Reason} +%%% @equiv exec(SSH,Command,DefaultTimeout) +exec(SSH, Command) -> + exec(SSH, undefined, Command, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec exec(SSH,Command,Timeout) -> {ok,Data} | {error,Reason} +%%% SSH = connection() +%%% Command = string() +%%% Timeout = integer() +%%% Data = list() +%%% Reason = term() +%%% +%%% @doc Requests server to perform <code>Command</code>. A session +%%% channel is opened automatically for the request. +%%% <code>Data</code> is received from the server as a result +%%% of the command. +exec(SSH, Command, Timeout) when is_list(Command) -> + exec(SSH, undefined, Command, Timeout); + +%%%----------------------------------------------------------------- +%%% @spec exec(SSH,ChannelId,Command) -> {ok,Data} | {error,Reason} +%%% @equiv exec(SSH,ChannelId,Command,DefaultTimeout) +exec(SSH, ChannelId, Command) when is_integer(ChannelId) -> + exec(SSH, ChannelId, Command, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec exec(SSH,ChannelId,Command,Timeout) -> {ok,Data} | {error,Reason} +%%% SSH = connection() +%%% ChannelId = integer() +%%% Command = string() +%%% Timeout = integer() +%%% Data = list() +%%% Reason = term() +%%% +%%% @doc Requests server to perform <code>Command</code>. A previously +%%% opened session channel is used for the request. +%%% <code>Data</code> is received from the server as a result +%%% of the command. +exec(SSH, ChannelId, Command, Timeout) -> + call(SSH, {exec,ChannelId,Command,Timeout}). + +%%%----------------------------------------------------------------- +%%% @spec receive_response(SSH,ChannelId) -> {ok,Data} | {error,Reason} +%%% @equiv receive_response(SSH,ChannelId,close) +receive_response(SSH, ChannelId) -> + receive_response(SSH, ChannelId, close, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec receive_response(SSH,ChannelId,End) -> {ok,Data} | {error,Reason} +%%% @equiv receive_response(SSH,ChannelId,End,DefaultTimeout) +receive_response(SSH, ChannelId, End) when is_function(End) -> + receive_response(SSH, ChannelId, End, ?DEFAULT_TIMEOUT); + +%%%----------------------------------------------------------------- +%%% @spec receive_response(SSH,ChannelId,Timeout) -> {ok,Data} | {error,Reason} +%%% @equiv receive_response(SSH,ChannelId,close,Timeout) +receive_response(SSH, ChannelId, Timeout) when is_integer(Timeout) -> + receive_response(SSH, ChannelId, close, Timeout). + +%%%----------------------------------------------------------------- +%%% @spec receive_response(SSH,ChannelId,End,Timeout) -> +%%% {ok,Data} | {timeout,Data} | {error,Reason} +%%% SSH = connection() +%%% ChannelId = integer() +%%% End = Fun | close | timeout +%%% Timeout = integer() +%%% Data = list() +%%% Reason = term() +%%% +%%% @doc Receives expected data from server on the specified +%%% session channel. +%%% +%%% <p>If <code>End == close</code>, data is returned +%%% to the caller when the channel is closed by the +%%% server. If a timeout occurs before this happens, +%%% the function returns <code>{timeout,Data}</code> +%%% (where <code>Data</code> is the data received so far). +%%% If <code>End == timeout</code>, a timeout is expected +%%% and <code>{ok,Data}</code> is returned both in the case +%%% of a timeout and when the channel is closed. If +%%% <code>End</code> is a fun, this fun will be +%%% called with one argument - the data value in a received +%%% <code>ssh_cm</code> message (see ssh_connection(3)). The +%%% fun should return <code>true</code> to end the receiving +%%% operation (and have the so far collected data returned), or +%%% <code>false</code> to wait for more data from the server. +%%% (Note that even if a fun is supplied, the function returns +%%% immediately if the server closes the channel).</p> +receive_response(SSH, ChannelId, End, Timeout) -> + call(SSH, {receive_response,ChannelId,End,Timeout}). + +%%%----------------------------------------------------------------- +%%% @spec send(SSH,ChannelId,Data) -> ok | {error,Reason} +%%% @equiv send(SSH,ChannelId,0,Data,DefaultTimeout) +send(SSH, ChannelId, Data) -> + send(SSH, ChannelId, 0, Data, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec send(SSH,ChannelId,Data,Timeout) -> ok | {error,Reason} +%%% @equiv send(SSH,ChannelId,0,Data,Timeout) +send(SSH, ChannelId, Data, Timeout) when is_integer(Timeout) -> + send(SSH, ChannelId, 0, Data, Timeout); + +%%%----------------------------------------------------------------- +%%% @spec send(SSH,ChannelId,Type,Data) -> ok | {error,Reason} +%%% @equiv send(SSH,ChannelId,Type,Data,DefaultTimeout) +send(SSH, ChannelId, Type, Data) when is_integer(Type) -> + send(SSH, ChannelId, Type, Data, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec send(SSH,ChannelId,Type,Data,Timeout) -> ok | {error,Reason} +%%% SSH = connection() +%%% ChannelId = integer() +%%% Type = integer() +%%% Data = list() +%%% Timeout = integer() +%%% Reason = term() +%%% +%%% @doc Send data to server on specified session channel. +send(SSH, ChannelId, Type, Data, Timeout) -> + call(SSH, {send,ChannelId,Type,Data,Timeout}). + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Data) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,Data,close) +send_and_receive(SSH, ChannelId, Data) -> + send_and_receive(SSH, ChannelId, 0, Data, close, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Data,End) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,0,Data,End,DefaultTimeout) +send_and_receive(SSH, ChannelId, Data, End) when is_function(End) -> + send_and_receive(SSH, ChannelId, 0, Data, End, ?DEFAULT_TIMEOUT); + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Data,Timeout) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,0,Data,close,Timeout) +send_and_receive(SSH, ChannelId, Data, Timeout) when is_integer(Timeout) -> + send_and_receive(SSH, ChannelId, 0, Data, close, Timeout); + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Type,Data) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,Type,Data,close,DefaultTimeout) +send_and_receive(SSH, ChannelId, Type, Data) when is_integer(Type) -> + send_and_receive(SSH, ChannelId, Type, Data, close, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Data,End,Timeout) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,0,Data,End,Timeout) +send_and_receive(SSH, ChannelId, Data, End, Timeout) when is_integer(Timeout) -> + send_and_receive(SSH, ChannelId, 0, Data, End, Timeout); + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Type,Data,Timeout) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,Type,Data,close,Timeout) +send_and_receive(SSH, ChannelId, Type, Data, Timeout) when is_integer(Type) -> + send_and_receive(SSH, ChannelId, Type, Data, close, Timeout); + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Type,Data,End) -> +%%% {ok,Data} | {error,Reason} +%%% @equiv send_and_receive(SSH,ChannelId,Type,Data,End,DefaultTimeout) +send_and_receive(SSH, ChannelId, Type, Data, End) when is_function(End) -> + send_and_receive(SSH, ChannelId, Type, Data, End, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec send_and_receive(SSH,ChannelId,Type,Data,End,Timeout) -> +%%% {ok,Data} | {error,Reason} +%%% SSH = connection() +%%% ChannelId = integer() +%%% Type = integer() +%%% Data = list() +%%% End = Fun | close | timeout +%%% Timeout = integer() +%%% Reason = term() +%%% +%%% @doc Send data to server on specified session channel and wait +%%% to receive the server response. +%%% +%%% <p>See <code>receive_response/4</code> for details on the +%%% <code>End</code> argument.</p> +send_and_receive(SSH, ChannelId, Type, Data, End, Timeout) -> + call(SSH, {send_and_receive,ChannelId,Type,Data,End,Timeout}). + +%%%----------------------------------------------------------------- +%%% @spec subsystem(SSH,ChannelId,Subsystem) -> Status | {error,Reason} +%%% @equiv subsystem(SSH,ChannelId,Subsystem,DefaultTimeout) +subsystem(SSH, ChannelId, Subsystem) -> + subsystem(SSH, ChannelId, Subsystem, ?DEFAULT_TIMEOUT). + +%%%----------------------------------------------------------------- +%%% @spec subsystem(SSH,ChannelId,Subsystem,Timeout) -> +%%% Status | {error,Reason} +%%% SSH = connection() +%%% ChannelId = integer() +%%% Subsystem = string() +%%% Timeout = integer() +%%% Status = success | failure +%%% Reason = term() +%%% +%%% @doc Sends a request to execute a predefined subsystem. +subsystem(SSH, ChannelId, Subsystem, Timeout) -> + call(SSH, {subsystem,ChannelId,Subsystem,Timeout}). + + +%%%----------------------------------------------------------------- +%%%------------------------ SFTP COMMANDS -------------------------- + +%%%----------------------------------------------------------------- +%%% @spec sftp_connect(SSH) -> {ok,Server} | {error,Reason} +%%% SSH = connection() +%%% Server = pid() +%%% Reason = term() +%%% @doc Starts an SFTP session on an already existing SSH connection. +%%% <code>Server</code> identifies the new session and must be +%%% specified whenever SFTP requests are to be sent. +sftp_connect(SSH) -> + call(SSH, sftp_connect). + +%%%----------------------------------------------------------------- +%%% @spec read_file(SSH, File) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_file(SSH, File) -> + call(SSH, {read_file,sftp,File}). +%%%----------------------------------------------------------------- +%%% @spec read_file(SSH, Server, File) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_file(SSH, Server, File) -> + call(SSH, {read_file,Server,File}). + +%%%----------------------------------------------------------------- +%%% @spec write_file(SSH, File, Iolist) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +write_file(SSH, File, Iolist) -> + call(SSH, {write_file,sftp,File,Iolist}). +%%%----------------------------------------------------------------- +%%% @spec write_file(SSH, Server, File, Iolist) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +write_file(SSH, Server, File, Iolist) -> + call(SSH, {write_file,Server,File,Iolist}). + +%%%----------------------------------------------------------------- +%%% @spec list_dir(SSH, Path) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +list_dir(SSH, Path) -> + call(SSH, {list_dir,sftp,Path}). +%%%----------------------------------------------------------------- +%%% @spec list_dir(SSH, Server, Path) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +list_dir(SSH, Server, Path) -> + call(SSH, {list_dir,Server,Path}). + +%%%----------------------------------------------------------------- +%%% @spec open(SSH, File, Mode) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +open(SSH, File, Mode) -> + call(SSH, {open,sftp,File,Mode}). +%%%----------------------------------------------------------------- +%%% @spec open(SSH, Server, File, Mode) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +open(SSH, Server, File, Mode) -> + call(SSH, {open,Server,File,Mode}). + +%%%----------------------------------------------------------------- +%%% @spec opendir(SSH, Path) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +opendir(SSH, Path) -> + call(SSH, {opendir,sftp,Path}). +%%%----------------------------------------------------------------- +%%% @spec opendir(SSH, Server, Path) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +opendir(SSH, Server, Path) -> + call(SSH, {opendir,Server,Path}). + +%%%----------------------------------------------------------------- +%%% @spec close(SSH, Handle) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +close(SSH, Handle) -> + call(SSH, {close,sftp,Handle}). +%%%----------------------------------------------------------------- +%%% @spec close(SSH, Server, Handle) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +close(SSH, Server, Handle) -> + call(SSH, {close,Server,Handle}). + +%%%----------------------------------------------------------------- +%%% @spec read(SSH, Handle, Len) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read(SSH, Handle, Len) -> + call(SSH, {read,sftp,Handle,Len}). +%%%----------------------------------------------------------------- +%%% @spec read(SSH, Server, Handle, Len) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read(SSH, Server, Handle, Len) -> + call(SSH, {read,Server,Handle,Len}). + +%%%----------------------------------------------------------------- +%%% @spec pread(SSH, Handle, Position, Length) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +pread(SSH, Handle, Position, Length) -> + call(SSH, {pread,sftp,Handle,Position,Length}). +%%%----------------------------------------------------------------- +%%% @spec pread(SSH, Server, Handle, Position, Length) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +pread(SSH, Server, Handle, Position, Length) -> + call(SSH, {pread,Server,Handle,Position,Length}). + +%%%----------------------------------------------------------------- +%%% @spec aread(SSH, Handle, Len) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +aread(SSH, Handle, Len) -> + call(SSH, {aread,sftp,Handle,Len}). +%%%----------------------------------------------------------------- +%%% @spec aread(SSH, Server, Handle, Len) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +aread(SSH, Server, Handle, Len) -> + call(SSH, {aread,Server,Handle,Len}). + +%%%----------------------------------------------------------------- +%%% @spec apread(SSH, Handle, Position, Length) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +apread(SSH, Handle, Position, Length) -> + call(SSH, {apread,sftp,Handle,Position,Length}). +%%%----------------------------------------------------------------- +%%% @spec apread(SSH, Server, Handle, Position, Length) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +apread(SSH, Server, Handle, Position, Length) -> + call(SSH, {apread,Server,Handle,Position,Length}). + +%%%----------------------------------------------------------------- +%%% @spec write(SSH, Handle, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +write(SSH, Handle, Data) -> + call(SSH, {write,sftp,Handle,Data}). +%%%----------------------------------------------------------------- +%%% @spec write(SSH, Server, Handle, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +write(SSH, Server, Handle, Data) -> + call(SSH, {write,Server,Handle,Data}). + +%%%----------------------------------------------------------------- +%%% @spec pwrite(SSH, Handle, Position, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +pwrite(SSH, Handle, Position, Data) -> + call(SSH, {pwrite,sftp,Handle,Position,Data}). +%%%----------------------------------------------------------------- +%%% @spec pwrite(SSH, Server, Handle, Position, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +pwrite(SSH, Server, Handle, Position, Data) -> + call(SSH, {pwrite,Server,Handle,Position,Data}). + +%%%----------------------------------------------------------------- +%%% @spec awrite(SSH, Handle, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +awrite(SSH, Handle, Data) -> + call(SSH, {awrite,sftp,Handle, Data}). +%%%----------------------------------------------------------------- +%%% @spec awrite(SSH, Server, Handle, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +awrite(SSH, Server, Handle, Data) -> + call(SSH, {awrite,Server,Handle, Data}). + +%%%----------------------------------------------------------------- +%%% @spec apwrite(SSH, Handle, Position, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +apwrite(SSH, Handle, Position, Data) -> + call(SSH, {apwrite,sftp,Handle,Position,Data}). +%%%----------------------------------------------------------------- +%%% @spec apwrite(SSH, Server, Handle, Position, Data) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +apwrite(SSH, Server, Handle, Position, Data) -> + call(SSH, {apwrite,Server,Handle,Position,Data}). + +%%%----------------------------------------------------------------- +%%% @spec position(SSH, Handle, Location) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +position(SSH, Handle, Location) -> + call(SSH, {position,sftp,Handle,Location}). +%%%----------------------------------------------------------------- +%%% @spec position(SSH, Server, Handle, Location) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +position(SSH, Server, Handle, Location) -> + call(SSH, {position,Server,Handle,Location}). + +%%%----------------------------------------------------------------- +%%% @spec read_file_info(SSH, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_file_info(SSH, Name) -> + call(SSH, {read_file_info,sftp,Name}). +%%%----------------------------------------------------------------- +%%% @spec read_file_info(SSH, Server, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_file_info(SSH, Server, Name) -> + call(SSH, {read_file_info,Server,Name}). + +%%%----------------------------------------------------------------- +%%% @spec get_file_info(SSH, Handle) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +get_file_info(SSH, Handle) -> + call(SSH, {get_file_info,sftp,Handle}). +%%%----------------------------------------------------------------- +%%% @spec get_file_info(SSH, Server, Handle) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +get_file_info(SSH, Server, Handle) -> + call(SSH, {get_file_info,Server,Handle}). + +%%%----------------------------------------------------------------- +%%% @spec read_link_info(SSH, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_link_info(SSH, Name) -> + call(SSH, {read_link_info,sftp,Name}). +%%%----------------------------------------------------------------- +%%% @spec read_link_info(SSH, Server, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_link_info(SSH, Server, Name) -> + call(SSH, {read_link_info,Server,Name}). + +%%%----------------------------------------------------------------- +%%% @spec write_file_info(SSH, Name, Info) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +write_file_info(SSH, Name, Info) -> + call(SSH, {write_file_info,sftp,Name,Info}). +%%%----------------------------------------------------------------- +%%% @spec write_file_info(SSH, Server, Name, Info) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +write_file_info(SSH, Server, Name, Info) -> + call(SSH, {write_file_info,Server,Name,Info}). + +%%%----------------------------------------------------------------- +%%% @spec read_link(SSH, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_link(SSH, Name) -> + call(SSH, {read_link,sftp,Name}). +%%%----------------------------------------------------------------- +%%% @spec read_link(SSH, Server, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +read_link(SSH, Server, Name) -> + call(SSH, {read_link,Server,Name}). + +%%%----------------------------------------------------------------- +%%% @spec make_symlink(SSH, Name, Target) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +make_symlink(SSH, Name, Target) -> + call(SSH, {make_symlink,sftp,Name,Target}). +%%%----------------------------------------------------------------- +%%% @spec make_symlink(SSH, Server, Name, Target) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +make_symlink(SSH, Server, Name, Target) -> + call(SSH, {make_symlink,Server,Name,Target}). + +%%%----------------------------------------------------------------- +%%% @spec rename(SSH, OldName, NewName) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +rename(SSH, OldName, NewName) -> + call(SSH, {rename,sftp,OldName,NewName}). +%%%----------------------------------------------------------------- +%%% @spec rename(SSH, Server, OldName, NewName) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +rename(SSH, Server, OldName, NewName) -> + call(SSH, {rename,Server,OldName,NewName}). + +%%%----------------------------------------------------------------- +%%% @spec delete(SSH, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +delete(SSH, Name) -> + call(SSH, {delete,sftp,Name}). +%%%----------------------------------------------------------------- +%%% @spec delete(SSH, Server, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +delete(SSH, Server, Name) -> + call(SSH, {delete,Server,Name}). + +%%%----------------------------------------------------------------- +%%% @spec make_dir(SSH, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +make_dir(SSH, Name) -> + call(SSH, {make_dir,sftp,Name}). +%%%----------------------------------------------------------------- +%%% @spec make_dir(SSH, Server, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +make_dir(SSH, Server, Name) -> + call(SSH, {make_dir,Server,Name}). + +%%%----------------------------------------------------------------- +%%% @spec del_dir(SSH, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +del_dir(SSH, Name) -> + call(SSH, {del_dir,sftp,Name}). +%%%----------------------------------------------------------------- +%%% @spec del_dir(SSH, Server, Name) -> Result +%%% SSH = connection() +%%% Result = ssh_sftp_return() | {error,Reason} +%%% Reason = term() +%%% @doc For info and other types, see ssh_sftp(3). +del_dir(SSH, Server, Name) -> + call(SSH, {del_dir,Server,Name}). + + +%%%================================================================= +%%% Callback functions +%%%================================================================= + +%% @hidden +init(KeyOrName, {ConnType,Addr,Port}, AllOpts) -> + User = proplists:get_value(user, AllOpts), + Password = case proplists:get_value(password, AllOpts) of + undefined -> ""; + Pwd -> Pwd + end, + AllOpts1 = case proplists:get_value(connect_timeout, AllOpts) of + undefined -> + [{connect_timeout,?DEFAULT_TIMEOUT}|AllOpts]; + _ -> + AllOpts + end, + Options = + lists:foldl(fun({ssh,_},Opts) -> Opts; + ({sftp,_},Opts) -> Opts; + ({port,_},Opts) -> Opts; + ({silently_accept_hosts,_},Opts) -> Opts; + ({user_interaction,_},Opts) -> Opts; + (Opt={Key,_},Opts) -> + case lists:keymember(Key, 1, Opts) of + true -> Opts; + false -> [Opt|Opts] + end; + (_,Opts) -> Opts + end, [], AllOpts1), + FinalOptions = [{silently_accept_hosts,true}, + {user_interaction,false} | Options], + crypto:start(), + ssh:start(), + Result = case ConnType of + ssh -> + ssh:connect(Addr, Port, FinalOptions); + sftp -> + ssh_sftp:connect(Addr, Port, FinalOptions) + end, + case Result of + {ok,SSHRef} -> + log(heading(init,KeyOrName), + "Opened ~w connection:\nHost: ~p (~p)\nUser: ~p\nPassword: ~p\n", + [ConnType,Addr,Port,User,lists:duplicate(length(Password),$*)]), + {ok,SSHRef,#state{ssh_ref=SSHRef, conn_type=ConnType, + target=KeyOrName}}; + Error -> + Error + end. + +%% @hidden +handle_msg(sftp_connect, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(sftp_connect,Target), "SSH Ref: ~p", [SSHRef]), + {ssh_sftp:connect(SSHRef),State}; + +handle_msg({session_open,TO}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(session_open,Target), "SSH Ref: ~p, Timeout: ~p", [SSHRef,TO]), + {ssh_connection:session_channel(SSHRef, TO),State}; + +handle_msg({session_close,Chn}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(session_close,Target), "SSH Ref: ~p, Chn: ~p", [SSHRef,Chn]), + {ssh_connection:close(SSHRef, Chn),State}; + +handle_msg({exec,Chn,Command,TO}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + Chn1 = + if Chn == undefined -> + log(heading(exec,Target), + "Opening channel for exec, SSH Ref: ~p", [SSHRef]), + case ssh_connection:session_channel(SSHRef, TO) of + {ok,C} -> C; + CErr -> CErr + end; + true -> + Chn + end, + case Chn1 of + {error,_} = ChnError -> + log(heading(exec,Target), "Opening channel failed: ~p", [ChnError]), + {ChnError,State}; + _ -> + log(heading(exec,Target), + "SSH Ref: ~p, Chn: ~p, Command: ~p, Timeout: ~p", + [SSHRef,Chn1,Command,TO]), + case ssh_connection:exec(SSHRef, Chn1, Command, TO) of + success -> + Result = do_recv_response(SSHRef, Chn1, [], close, TO), + ssh_connection:close(SSHRef, Chn1), + {Result,State}; + Other -> + {{error,Other},State} + end + end; + +handle_msg({receive_response,Chn,End,TO}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(receive_response,Target), + "SSH Ref: ~p, Chn: ~p, Timeout: ~p", [SSHRef,Chn,TO]), + Result = do_recv_response(SSHRef, Chn, [], End, TO), + {Result,State}; + +handle_msg({send,Chn,Type,Data,TO}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(send,Target), + "SSH Ref: ~p, Chn: ~p, Type: ~p, Timeout: ~p~n" + "Data: ~p", [SSHRef,Chn,Type,TO,Data]), + Result = ssh_connection:send(SSHRef, Chn, Type, Data, TO), + {Result,State}; + +handle_msg({send_and_receive,Chn,Type,Data,End,TO}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(send_and_receive,Target), + "SSH Ref: ~p, Chn: ~p, Type: ~p, Timeout: ~p~n" + "Data: ~p", [SSHRef,Chn,Type,TO,Data]), + case ssh_connection:send(SSHRef, Chn, Type, Data, TO) of + ok -> + Result = do_recv_response(SSHRef, Chn, [], End, TO), + {Result,State}; + Error -> + {Error,State} + end; + +handle_msg({subsystem,Chn,Subsystem,TO}, State) -> + #state{ssh_ref=SSHRef, target=Target} = State, + log(heading(subsystem,Target), + "SSH Ref: ~p, Chn: ~p, Subsys: ~p, Timeout: ~p", + [SSHRef,Chn,Subsystem,TO]), + Result = ssh_connection:subsystem(SSHRef, Chn, Subsystem, TO), + {Result,State}; + +%% --- SFTP Commands --- + +handle_msg({read_file,Srv,File}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:read_file(ref(Srv,SSHRef), File),S}; + +handle_msg({write_file,Srv,File,Iolist}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:write_file(ref(Srv,SSHRef), File, Iolist),S}; + +handle_msg({list_dir,Srv,Path}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:list_dir(ref(Srv,SSHRef), Path),S}; + +handle_msg({open,Srv,File,Mode}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:open(ref(Srv,SSHRef), File, Mode),S}; + +handle_msg({opendir,Srv,Path}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:opendir(ref(Srv,SSHRef), Path),S}; + +handle_msg({close,Srv,Handle}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:close(ref(Srv,SSHRef), Handle),S}; + +handle_msg({read,Srv,Handle,Len}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:read(ref(Srv,SSHRef), Handle, Len),S}; + +handle_msg({pread,Srv,Handle,Position,Length}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:pread(ref(Srv,SSHRef),Handle,Position,Length),S}; + +handle_msg({aread,Srv,Handle,Len}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:aread(ref(Srv,SSHRef), Handle, Len),S}; + +handle_msg({apread,Srv,Handle,Position,Length}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:apread(ref(Srv,SSHRef), Handle, Position, Length),S}; + +handle_msg({write,Srv,Handle,Data}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:write(ref(Srv,SSHRef), Handle, Data),S}; + +handle_msg({pwrite,Srv,Handle,Position,Data}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:pwrite(ref(Srv,SSHRef), Handle, Position, Data),S}; + +handle_msg({awrite,Srv,Handle,Data}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:awrite(ref(Srv,SSHRef), Handle, Data),S}; + +handle_msg({apwrite,Srv,Handle,Position,Data}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:apwrite(ref(Srv,SSHRef), Handle, Position, Data),S}; + +handle_msg({position,Srv,Handle,Location}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:position(ref(Srv,SSHRef), Handle, Location),S}; + +handle_msg({read_file_info,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:read_file_info(ref(Srv,SSHRef), Name),S}; + +handle_msg({get_file_info,Srv,Handle}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:get_file_info(ref(Srv,SSHRef), Handle),S}; + +handle_msg({read_link_info,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:read_link_info(ref(Srv,SSHRef), Name),S}; + +handle_msg({write_file_info,Srv,Name,Info}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:write_file_info(ref(Srv,SSHRef), Name, Info),S}; + +handle_msg({read_link,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:read_link(ref(Srv,SSHRef), Name),S}; + +handle_msg({make_symlink,Srv,Name,Target}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:make_symlink(ref(Srv,SSHRef), Name, Target),S}; + +handle_msg({rename,Srv,OldName,NewName}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:rename(ref(Srv,SSHRef), OldName, NewName),S}; + +handle_msg({delete,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:delete(ref(Srv,SSHRef), Name),S}; + +handle_msg({make_dir,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:make_dir(ref(Srv,SSHRef), Name),S}; + +handle_msg({del_dir,Srv,Name}=Cmd, S=#state{ssh_ref=SSHRef}) -> + log(heading(sftp,S#state.target), + "SSH Ref: ~p, Server: ~p~nCmd: ~p", [SSHRef,ref(Srv,SSHRef),mod(Cmd)]), + {ssh_sftp:del_dir(ref(Srv,SSHRef), Name),S}. + +%% @hidden +reconnect(_Addr,_State) -> + {error,no_reconnection_of_ssh}. + +%% @hidden +close(SSHRef) -> + disconnect(SSHRef). + +%% @hidden +terminate(SSHRef, State) -> + case State#state.conn_type of + ssh -> + log(heading(disconnect_ssh,State#state.target), + "SSH Ref: ~p",[SSHRef]), + ssh:close(SSHRef); + sftp -> + log(heading(disconnect_sftp,State#state.target), + "SFTP Ref: ~p",[SSHRef]), + ssh_sftp:stop(SSHRef) + end. + + +%%%================================================================= +%%% Internal functions + +%%%----------------------------------------------------------------- +%%% +do_recv_response(SSH, Chn, Data, End, Timeout) -> + receive + + {ssh_cm, SSH, {open,Chn,RemoteChn,{session}}} -> + debug("RECVD open"), + {ok,{open,Chn,RemoteChn,{session}}}; + + {ssh_cm, SSH, {closed,Chn}} -> + ssh_connection:close(SSH, Chn), + debug("CLSD~n~p ~p", [SSH,Chn]), + {ok,Data}; + + {ssh_cm, SSH, {data,Chn,_,NewData}} -> + ssh_connection:adjust_window(SSH, Chn, size(NewData)), + debug("RECVD~n~p", [binary_to_list(NewData)]), + DataAcc = Data ++ binary_to_list(NewData), + if is_function(End) -> + case End(DataAcc) of + true -> + {ok,DataAcc}; + false -> + do_recv_response(SSH, Chn, DataAcc, End, Timeout) + end; + true -> + do_recv_response(SSH, Chn, DataAcc, End, Timeout) + end; + + {ssh_cm, SSH, {eof,Chn}} -> + debug("RECVD EOF~n~p ~p", [SSH,Chn]), + {ok,Data}; + + {ssh_cm, SSH, {exit_signal,Chn,Signal,Err,_Lang}} -> + debug("RECVD exit_signal~n~p ~p~n~p ~p", [SSH,Chn,Signal,Err]), + do_recv_response(SSH, Chn, Data, End, Timeout); +%% {ok,{exit_signal,Chn,Signal,Err,_Lang}}; + + {ssh_cm, SSH, {exit_status,Chn,Status}} -> + debug("RECVD exit_status~n~p ~p~n~p", [SSH,Chn,Status]), + do_recv_response(SSH, Chn, Data, End, Timeout); +%% {ok,{exit_status,Chn,_Status}}; + + +%% --- INTERACTIVE MESSAGES - NOT HANDLED --- +%% +%% {ssh_cm, SSH, {subsystem,Chn,WantReply,Name}} -> +%% debug("RECVD SUBS WNTRPLY~n~p ~p~n~p~n~p", +%% [SSH,Chn,WantReply]), +%% ssh_connection:reply_request(SSH, WantReply, success, Chn), +%% do_recv_response(SSH, Chn, Data, End, Timeout); + +%% {ssh_cm, SSH, {shell,WantReply}} -> +%% debug("RECVD SHELL WNTRPLY~n~p ~p~n~p~n~p", +%% [SSH,Chn,WantReply]), +%% ssh_connection:reply_request(SSH, WantReply, success, Chn), +%% do_recv_response(SSH,Chn,Data,End,Timeout); + +%% {ssh_cm, SSH, {pty,Chn,WantReply,Pty}} -> +%% debug("RECVD PTY WNTRPLY~n~p ~p~n~p~n~p", +%% [SSH,Chn,WantReply,Pty]), +%% ssh_connection:reply_request(SSH, WantReply, success, Chn), +%% do_recv_response(SSH, Chn, Data, End, Timeout); + +%% {ssh_cm, SSH, WCh={window_change,_Chn,_Width,_Height,_PixWidth,_PixHeight}} -> +%% debug("RECVD WINCH"), +%% {ok,WCh}; + + Other -> + debug("UNEXPECTED MESSAGE~n~p ~p~n~p", [SSH,Chn,Other]), + do_recv_response(SSH, Chn, Data, End, Timeout) + + after Timeout -> + case End of + timeout -> + {ok,Data}; + _ -> + {timeout,Data} + end + end. + +%%%----------------------------------------------------------------- +%%% +get_handle(SSH) when is_pid(SSH) -> + {ok,SSH}; +get_handle(SSH) -> + case ct_util:get_connections(SSH, ?MODULE) of + {ok,[{Pid,_}]} -> + {ok,Pid}; + {ok,[]} -> + connect(SSH); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% +call(SSH, Msg) -> + case get_handle(SSH) of + {ok,Pid} -> + ct_gen_conn:call(Pid, Msg); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% +ref(sftp, SSHRef) -> SSHRef; +ref(Server, _) -> Server. + +%%%----------------------------------------------------------------- +%%% +mod(Cmd) -> + [Op,_Server|Args] = tuple_to_list(Cmd), + list_to_tuple([Op|Args]). + +%%%----------------------------------------------------------------- +%%% +heading(Function, Ref) -> + io_lib:format("ct_ssh:~w ~p",[Function,Ref]). + +%%%----------------------------------------------------------------- +%%% +log(Heading, Str, Args) -> + ct_gen_conn:log(Heading, Str, Args). + + +%%%----------------------------------------------------------------- +%%% +debug(Str) -> + debug(Str, []). + +debug(_Str, _Args) -> +%% io:format("~n--- ct_ssh debug ---~n" ++ _Str ++ "~n", _Args), + ok. diff --git a/lib/common_test/src/ct_telnet.erl b/lib/common_test/src/ct_telnet.erl new file mode 100644 index 0000000000..c19d312f01 --- /dev/null +++ b/lib/common_test/src/ct_telnet.erl @@ -0,0 +1,1166 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test specific layer on top of telnet client ct_telnet_client.erl +%%% +%%% <p>Use this module to set up telnet connections, send commands and +%%% perform string matching on the result. +%%% (See the <code>unix_telnet</code> manual page for information +%%% about how ct_telnet may be used specifically with unix hosts.)</p> +%%% <p>The following default values are defined in ct_telnet:</p> +%%% <pre> +%%% Connection timeout = 10 sec (time to wait for connection) +%%% Command timeout = 10 sec (time to wait for a command to return) +%%% Max no of reconnection attempts = 3 +%%% Reconnection interval = 5 sek (time to wait in between reconnection attempts) +%%% </pre> +%%% <p>These parameters can be altered by the user with the following +%%% configuration term:</p> +%%% <pre> +%%% {telnet_settings, [{connect_timeout,Millisec}, +%%% {command_timeout,Millisec}, +%%% {reconnection_attempts,N}, +%%% {reconnection_interval,Millisec}]}. +%%% </pre> +%%% <p><code>Millisec = integer(), N = integer()</code></p> +%%% <p>Enter the <code>telnet_settings</code> term in a configuration +%%% file included in the test and ct_telnet will retrieve the information +%%% automatically.</p> + +%%% @type connection_type() = telnet | ts1 | ts2 + +%%% @type connection() = handle() | +%%% {ct:target_name(),connection_type()} | ct:target_name() + +%%% @type handle() = ct_gen_conn:handle(). Handle for a +%%% specific telnet connection. + +%%% @type prompt_regexp() = string(). A regular expression which +%%% matches all possible prompts for a specific type of target. The +%%% regexp must not have any groups i.e. when matching, re:run/3 shall +%%% return a list with one single element. +%%% +%%% @see unix_telnet + +-module(ct_telnet). + +-compile(export_all). + +-export([open/1, open/2, open/3, open/4, close/1]). +-export([cmd/2, cmd/3, cmdf/3, cmdf/4, get_data/1, + send/2, sendf/3, expect/2, expect/3]). + +%% Callbacks +-export([init/3,handle_msg/2,reconnect/2,terminate/2]). + +%% Tool internals +-export([silent_teln_expect/5, teln_receive_until_prompt/3, + start_log/1, log/3, cont_log/2, end_log/0, + try_start_log/1, try_log/3, try_cont_log/2, try_end_log/0]). + + +-define(RECONNS,3). +-define(RECONN_TIMEOUT,5000). +-define(DEFAULT_TIMEOUT,10000). +-define(DEFAULT_PORT,23). + +-include("ct_util.hrl"). + +-record(state,{teln_pid, + prx, + type, + buffer=[], + prompt=false, + name, + target_mod,extra, + conn_to=?DEFAULT_TIMEOUT, + com_to=?DEFAULT_TIMEOUT, + reconns=?RECONNS, + reconn_int=?RECONN_TIMEOUT}). + +%%%----------------------------------------------------------------- +%%% @spec open(Name) -> {ok,Handle} | {error,Reason} +%%% @equiv open(Name,telnet) +open(Name) -> + open(Name,telnet). + +%%%----------------------------------------------------------------- +%%% @spec open(Name,ConnType) -> {ok,Handle} | {error,Reason} +%%% Name = target_name() +%%% ConnType = ct_telnet:connection_type() +%%% Handle = ct_telnet:handle() +%%% +%%% @doc Open a telnet connection to the specified target host. +open(Name,ConnType) -> + case ct_util:get_key_from_name(Name) of + {ok, unix} -> % unix host + open(Name, ConnType, unix_telnet, Name); + {ok, Key} -> % any other, e.g. interwatch (iw), etc. + open(Name, ConnType, Key, Name); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec open(KeyOrName,ConnType,TargetMod) -> +%%% {ok,Handle} | {error,Reason} +%%% @equiv open(KeyOrName,ConnType,TargetMod,[]) +open(KeyOrName,ConnType,TargetMod) -> + open(KeyOrName,ConnType,TargetMod,KeyOrName). + +%%%----------------------------------------------------------------- +%%% @spec open(KeyOrName,ConnType,TargetMod,Extra) -> +%%% {ok,Handle} | {error,Reason} +%%% KeyOrName = Key | Name +%%% Key = atom() +%%% Name = ct:target_name() +%%% ConnType = connection_type() +%%% TargetMod = atom() +%%% Extra = term() +%%% Handle = handle() +%%% +%%% @doc Open a telnet connection to the specified target host. +%%% +%%% <p>The target data must exist in a configuration file. The connection +%%% may be associated with either <code>Name</code> and/or the returned +%%% <code>Handle</code>. To allocate a name for the target, +%%% use <code>ct:require/2</code> in a test case, or use a +%%% <code>require</code> statement in the suite info function +%%% (<code>suite/0</code>), or in a test case info function. +%%% If you want the connection to be associated with <code>Handle</code> only +%%% (in case you need to open multiple connections to a host for example), +%%% simply use <code>Key</code>, the configuration variable name, to +%%% specify the target. Note that a connection that has no associated target +%%% name can only be closed with the handle value.</p> +%%% +%%% <p><code>TargetMod</code> is a module which exports the functions +%%% <code>connect(Ip,Port,Extra)</code> and <code>get_prompt_regexp()</code> +%%% for the given <code>TargetType</code> (e.g. <code>unix_telnet</code>).</p> +open(KeyOrName,ConnType,TargetMod,Extra) -> + case ct:get_config({KeyOrName,ConnType}) of + undefined -> + log(heading(open,{KeyOrName,ConnType}),"Failed: ~p", + [{not_available,KeyOrName}]), + {error,{not_available,KeyOrName,ConnType}}; + Addr -> + Addr1 = + case Addr of + {_IP,_Port} -> + Addr; + IP -> + case ct:get_config({KeyOrName,port}) of + undefined -> IP; + P -> {IP,P} + end + end, + log(heading(open,{KeyOrName,ConnType}),"Opening connection to: ~p",[Addr1]), + ct_gen_conn:start(KeyOrName,full_addr(Addr1,ConnType), + {TargetMod,Extra},?MODULE) + end. + +%%%----------------------------------------------------------------- +%%% @spec close(Connection) -> ok | {error,Reason} +%%% Connection = ct_telnet:connection() +%%% +%%% @doc Close the telnet connection and stop the process managing it. +%%% +%%% <p>A connection may be associated with a target name and/or a handle. +%%% If <code>Connection</code> has no associated target name, it may only +%%% be closed with the handle value (see the <code>open/4</code> +%%% function).</p> +close(Connection) -> + case get_handle(Connection) of + {ok,Pid} -> + log("ct_telnet:close","Handle: ~p",[Pid]), + case ct_gen_conn:stop(Pid) of + {error,{process_down,Pid,noproc}} -> + {error,already_closed}; + Result -> + Result + end; + Error -> + Error + end. + +%%%================================================================= +%%% Test suite interface +%%%----------------------------------------------------------------- +%%% @spec cmd(Connection,Cmd) -> {ok,Data} | {error,Reason} +%%% @equiv cmd(Connection,Cmd,DefaultTimeout) +cmd(Connection,Cmd) -> + cmd(Connection,Cmd,default). +%%%----------------------------------------------------------------- +%%% @spec cmd(Connection,Cmd,Timeout) -> {ok,Data} | {error,Reason} +%%% Connection = ct_telnet:connection() +%%% Cmd = string() +%%% Timeout = integer() +%%% Data = [string()] +%%% @doc Send a command via telnet and wait for prompt. +cmd(Connection,Cmd,Timeout) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{cmd,Cmd,Timeout}); + Error -> + Error + end. +%%%----------------------------------------------------------------- +%%% @spec cmdf(Connection,CmdFormat,Args) -> {ok,Data} | {error,Reason} +%%% @equiv cmdf(Connection,CmdFormat,Args,DefaultTimeout) +cmdf(Connection,CmdFormat,Args) -> + cmdf(Connection,CmdFormat,Args,default). +%%%----------------------------------------------------------------- +%%% @spec cmdf(Connection,CmdFormat,Args,Timeout) -> {ok,Data} | {error,Reason} +%%% Connection = ct_telnet:connection() +%%% CmdFormat = string() +%%% Args = list() +%%% Timeout = integer() +%%% Data = [string()] +%%% @doc Send a telnet command and wait for prompt +%%% (uses a format string and list of arguments to build the command). +%%%----------------------------------------------------------------- +cmdf(Connection,CmdFormat,Args,Timeout) when is_list(Args) -> + Cmd = lists:flatten(io_lib:format(CmdFormat,Args)), + cmd(Connection,Cmd,Timeout). + +%%%----------------------------------------------------------------- +%%% @spec get_data(Connection) -> {ok,Data} | {error,Reason} +%%% Connection = ct_telnet:connection() +%%% Data = [string()] +%%% @doc Get all data which has been received by the telnet client +%%% since last command was sent. +get_data(Connection) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,get_data); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec send(Connection,Cmd) -> ok | {error,Reason} +%%% Connection = ct_telnet:connection() +%%% Cmd = string() +%%% @doc Send a telnet command and return immediately. +%%% +%%% <p>The resulting output from the command can be read with +%%% <code>get_data/1</code> or <code>expect/2/3</code>.</p> +send(Connection,Cmd) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{send,Cmd}); + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @spec sendf(Connection,CmdFormat,Args) -> ok | {error,Reason} +%%% Connection = ct_telnet:connection() +%%% CmdFormat = string() +%%% Args = list() +%%% @doc Send a telnet command and return immediately (uses a format +%%% string and a list of arguments to build the command). +sendf(Connection,CmdFormat,Args) when is_list(Args) -> + Cmd = lists:flatten(io_lib:format(CmdFormat,Args)), + send(Connection,Cmd). + +%%%----------------------------------------------------------------- +%%% @spec expect(Connection,Patterns) -> term() +%%% @equiv expect(Connections,Patterns,[]) +expect(Connection,Patterns) -> + expect(Connection,Patterns,[]). + +%%%----------------------------------------------------------------- +%%% @spec expect(Connection,Patterns,Opts) -> {ok,Match} | +%%% {ok,MatchList,HaltReason} | +%%% {error,Reason} +%%% Connection = ct_telnet:connection() +%%% Patterns = Pattern | [Pattern] +%%% Pattern = string() | {Tag,string()} | prompt | {prompt,Prompt} +%%% Prompt = string() +%%% Tag = term() +%%% Opts = [Opt] +%%% Opt = {timeout,Timeout} | repeat | {repeat,N} | sequence | +%%% {halt,HaltPatterns} | ignore_prompt +%%% Timeout = integer() +%%% N = integer() +%%% HaltPatterns = Patterns +%%% MatchList = [Match] +%%% Match = RxMatch | {Tag,RxMatch} | {prompt,Prompt} +%%% RxMatch = [string()] +%%% HaltReason = done | Match +%%% Reason = timeout | {prompt,Prompt} +%%% +%%% @doc Get data from telnet and wait for the expected pattern. +%%% +%%% <p><code>Pattern</code> can be a POSIX regular expression. If more +%%% than one pattern is given, the function returns when the first +%%% match is found.</p> +%%% +%%% <p><code>RxMatch</code> is a list of matched strings. It looks +%%% like this: <code>[FullMatch, SubMatch1, SubMatch2, ...]</code> +%%% where <code>FullMatch</code> is the string matched by the whole +%%% regular expression and <code>SubMatchN</code> is the string that +%%% matched subexpression no <code>N</code>. Subexpressions are +%%% denoted with '(' ')' in the regular expression</p> +%%% +%%% <p>If a <code>Tag</code> is given, the returned <code>Match</code> +%%% will also include the matched <code>Tag</code>. Else, only +%%% <code>RxMatch</code> is returned.</p> +%%% +%%% <p>The function will always return when a prompt is found, unless +%%% the <code>ignore_prompt</code> options is used.</p> +%%% +%%% <p>The <code>timeout</code> option indicates that the function +%%% shall return if the telnet client is idle (i.e. if no data is +%%% received) for more than <code>Timeout</code> milliseconds. Default +%%% timeout is 10 seconds.</p> +%%% +%%% <p>The <code>repeat</code> option indicates that the pattern(s) +%%% shall be matched multiple times. If <code>N</code> is given, the +%%% pattern(s) will be matched <code>N</code> times, and the function +%%% will return with <code>HaltReason = done</code>.</p> +%%% +%%% <p>The <code>sequence</code> option indicates that all patterns +%%% shall be matched in a sequence. A match will not be concluded +%%% untill all patterns are matched.</p> +%%% +%%% <p>Both <code>repeat</code> and <code>sequence</code> can be +%%% interrupted by one or more <code>HaltPatterns</code>. When +%%% <code>sequence</code> or <code>repeat</code> is used, there will +%%% always be a <code>MatchList</code> returned, i.e. a list of +%%% <code>Match</code> instead of only one <code>Match</code>. There +%%% will also be a <code>HaltReason</code> returned.</p> +%%% +%%% <p><underline>Examples:</underline><br/> +%%% <code>expect(Connection,[{abc,"ABC"},{xyz,"XYZ"}], +%%% [sequence,{halt,[{nnn,"NNN"}]}]).</code><br/> will try to match +%%% "ABC" first and then "XYZ", but if "NNN" appears the function will +%%% return <code>{error,{nnn,["NNN"]}}</code>. If both "ABC" and "XYZ" +%%% are matched, the function will return +%%% <code>{ok,[AbcMatch,XyzMatch]}</code>.</p> +%%% +%%% <p><code>expect(Connection,[{abc,"ABC"},{xyz,"XYZ"}], +%%% [{repeat,2},{halt,[{nnn,"NNN"}]}]).</code><br/> will try to match +%%% "ABC" or "XYZ" twice. If "NNN" appears the function will return +%%% with <code>HaltReason = {nnn,["NNN"]}</code>.</p> +%%% +%%% <p>The <code>repeat</code> and <code>sequence</code> options can be +%%% combined in order to match a sequence multiple times.</p> +expect(Connection,Patterns,Opts) -> + case get_handle(Connection) of + {ok,Pid} -> + call(Pid,{expect,Patterns,Opts}); + Error -> + Error + end. + +%%%================================================================= +%%% Callback functions +%% @hidden +init(Name,{Ip,Port,Type},{TargetMod,Extra}) -> + S0 = case ct:get_config(telnet_settings) of + undefined -> + #state{}; + Settings -> + set_telnet_defaults(Settings,#state{}) + end, + case catch TargetMod:connect(Ip,Port,S0#state.conn_to,Extra) of + {ok,TelnPid} -> + log(heading(init,{Name,Type}), + "Opened telnet connection\n" + "IP: ~p\n" + "Port: ~p\n" + "Command timeout: ~p\n" + "Reconnection attempts: ~p\n" + "Reconnection interval: ~p\n" + "Connection timeout: ~p", + [Ip,Port,S0#state.com_to,S0#state.reconns, + S0#state.reconn_int,S0#state.conn_to]), + {ok,TelnPid,S0#state{teln_pid=TelnPid, + type=type(Type), + name={Name,Type}, + target_mod=TargetMod, + extra=Extra, + prx=TargetMod:get_prompt_regexp()}}; + {'EXIT',Reason} -> + {error,Reason}; + Error -> + Error + end. + +type(telnet) -> ip; +type(TS) when TS==ts1;TS==ts2 -> ts. + +set_telnet_defaults([{connect_timeout,CnTo}|Ss],S) -> + set_telnet_defaults(Ss,S#state{conn_to=CnTo}); +set_telnet_defaults([{command_timeout,CmTo}|Ss],S) -> + set_telnet_defaults(Ss,S#state{com_to=CmTo}); +set_telnet_defaults([{reconnection_attempts,Rs}|Ss],S) -> + set_telnet_defaults(Ss,S#state{reconns=Rs}); +set_telnet_defaults([{reconnection_interval,RInt}|Ss],S) -> + set_telnet_defaults(Ss,S#state{reconn_int=RInt}); +set_telnet_defaults([],S) -> + S. + +%% @hidden +handle_msg({cmd,Cmd,Timeout},State) -> + try_start_log(heading(cmd,State#state.name)), + try_cont_log("Cmd: ~p", [Cmd]), + debug_cont_log("Throwing Buffer:",[]), + debug_log_lines(State#state.buffer), + case {State#state.type,State#state.prompt} of + {ts,_} -> + silent_teln_expect(State#state.teln_pid, + State#state.buffer, + prompt, + State#state.prx, + [{timeout,2000}]); + {ip,false} -> + silent_teln_expect(State#state.teln_pid, + State#state.buffer, + prompt, + State#state.prx, + [{timeout,200}]); + {ip,true} -> + ok + end, + TO = if Timeout == default -> State#state.com_to; + true -> Timeout + end, + {Return,NewBuffer,Prompt} = + case teln_cmd(State#state.teln_pid, Cmd, State#state.prx, TO) of + {ok,Data,_PromptType,Rest} -> + try_cont_log("Return: ~p", [{ok,Data}]), + {{ok,Data},Rest,true}; + Error -> + Retry = {retry,{Error,State#state.name,State#state.teln_pid, + {cmd,Cmd,TO}}}, + try_cont_log("Return: ~p", [Error]), + {Retry,[],false} + end, + try_end_log(), + {Return,State#state{buffer=NewBuffer,prompt=Prompt}}; +handle_msg({send,Cmd},State) -> + try_log(heading(send,State#state.name),"Cmd: ~p",[Cmd]), + debug_cont_log("Throwing Buffer:",[]), + debug_log_lines(State#state.buffer), + case {State#state.type,State#state.prompt} of + {ts,_} -> + silent_teln_expect(State#state.teln_pid, + State#state.buffer, + prompt, + State#state.prx, + [{timeout,2000}]); + {ip,false} -> + silent_teln_expect(State#state.teln_pid, + State#state.buffer, + prompt, + State#state.prx, + [{timeout,200}]); + {ip,true} -> + ok + end, + ct_telnet_client:send_data(State#state.teln_pid,Cmd), + {ok,State#state{buffer=[],prompt=false}}; +handle_msg(get_data,State) -> + try_start_log(heading(get_data,State#state.name)), + {ok,Data,Buffer} = teln_get_all_data(State#state.teln_pid, + State#state.prx, + State#state.buffer, + [],[]), + try_cont_log("Return: ~p",[{ok,Data}]), + try_end_log(), + {{ok,Data},State#state{buffer=Buffer}}; +handle_msg({expect,Pattern,Opts},State) -> + try_start_log(heading(expect,State#state.name)), + try_cont_log("Expect: ~p\nOpts=~p\n",[Pattern,Opts]), + {Return,NewBuffer,Prompt} = + case teln_expect(State#state.teln_pid, + State#state.buffer, + Pattern, + State#state.prx, + Opts) of + {ok,Data,Rest} -> + P = check_if_prompt_was_reached(Data,[]), + {{ok,Data},Rest,P}; + {ok,Data,HaltReason,Rest} -> + force_cont_log("HaltReason: ~p", + [HaltReason]), + P = check_if_prompt_was_reached(Data,HaltReason), + {{ok,Data,HaltReason},Rest,P}; + {error,Reason,Rest} -> + force_cont_log("Expect failed\n~p",[{error,Reason}]), + P = check_if_prompt_was_reached([],Reason), + {{error,Reason},Rest,P}; + {error,Reason} -> + force_cont_log("Expect failed\n~p",[{error,Reason}]), + P = check_if_prompt_was_reached([],Reason), + {{error,Reason},[],P} + end, + try_end_log(), + Return1 = case Return of + {error,_} -> {retry,{Return,State#state.name, + State#state.teln_pid, + {expect,Pattern,Opts}}}; + _ -> Return + end, + {Return1,State#state{buffer=NewBuffer,prompt=Prompt}}. + + +%% @hidden +reconnect({Ip,Port,_Type},State) -> + reconnect(Ip,Port,State#state.reconns,State). +reconnect(Ip,Port,N,State=#state{target_mod=TargetMod, + extra=Extra, + conn_to=ConnTo, + reconn_int=ReconnInt}) -> + case TargetMod:connect(Ip,Port,ConnTo,Extra) of + {ok, NewPid} -> + {ok, NewPid, State#state{teln_pid=NewPid}}; + Error when N==0 -> + Error; + _Error -> + log("Reconnect failed!","Retries left: ~p",[N]), + timer:sleep(ReconnInt), + reconnect(Ip,Port,N-1,State) + end. + + +%% @hidden +terminate(TelnPid,State) -> + log(heading(terminate,State#state.name), + "Closing telnet connection.\nId: ~p", + [TelnPid]), + ct_telnet_client:close(TelnPid). + + +%%%================================================================= +%%% Internal function +get_handle(Pid) when is_pid(Pid) -> + {ok,Pid}; +get_handle({Name,Type}) when Type==telnet;Type==ts1;Type==ts2 -> + case ct_util:get_connections(Name,?MODULE) of + {ok,Conns} when Conns /= [] -> + case get_handle(Type,Conns) of + {ok,Pid} -> + {ok,Pid}; + _Error -> + case ct_util:get_key_from_name(Name) of + {ok,node} -> + open(Name,Type,ct_telnet_cello_node); + {ok,unix} -> % unix host + open(Name,Type,unix_telnet,Name); + {ok,Key} -> % any other, e.g. interwatch (iw) + open(Name,Type,Key,Name); + Error -> + Error + end + end; + {ok,[]} -> + {error,already_closed}; + Error -> + Error + end; +get_handle(Name) -> + get_handle({Name,telnet}). + +get_handle(Type,[{Pid,{_,_,Type}}|_]) -> + {ok,Pid}; +get_handle(Type,[_H|T]) -> + get_handle(Type,T); +get_handle(Type,[]) -> + {error,{no_such_connection,Type}}. + +full_addr({Ip,Port},Type) -> + {Ip,Port,Type}; +full_addr(Ip,Type) -> + {Ip,?DEFAULT_PORT,Type}. + +call(Pid,Msg) -> + ct_gen_conn:call(Pid,Msg). + +check_if_prompt_was_reached({prompt,_},_) -> + true; +check_if_prompt_was_reached(_,{prompt,_}) -> + true; +check_if_prompt_was_reached(Data,_) when is_list(Data) -> + lists:keymember(prompt,1,Data); +check_if_prompt_was_reached(_,_) -> + false. + +%tc(Fun) -> +% Before = erlang:now(), +% Val = Fun(), +% After = erlang:now(), +% {now_diff(After, Before), Val}. +%now_diff({A2, B2, C2}, {A1, B1, C1}) -> +% ((A2-A1)*1000000 + B2-B1)*1000000 + C2-C1. + +heading(Function,Name) -> + io_lib:format("~w:~w ~p",[?MODULE,Function,Name]). + +%%% @hidden +%% Functions for regular (unconditional) logging, to be +%% used during connect, reconnect, disconnect etc. +log(Heading,Str,Args) -> + ct_gen_conn:log(Heading,Str,Args). +%%% @hidden +start_log(Heading) -> + ct_gen_conn:start_log(Heading). +cont_log(Str,Args) -> + ct_gen_conn:cont_log(Str,Args). +end_log() -> + ct_gen_conn:end_log(). + +%%% @hidden +%% Functions for conditional logging, to be used by +%% cmd, send, receive, expect etc (this output may be +%% silenced by user). +try_start_log(Heading) -> + do_try_log(start_log,[Heading]). +%%% @hidden +try_end_log() -> + do_try_log(end_log,[]). + +%%% @hidden +try_log(Heading,Str,Args) -> + do_try_log(log,[Heading,Str,Args]). + +%%% @hidden +try_cont_log(Str,Args) -> + do_try_log(cont_log,[Str,Args]). + +%%% @hidden +do_try_log(Func,Args) -> + %% check if output is suppressed + case ct_util:is_silenced(telnet) of + true -> + ok; + false -> + apply(ct_gen_conn,Func,Args) + end. + +%%% @hidden +%% Functions that will force printout even if ct_telnet +%% output has been silenced, to be used for error printouts. +force_cont_log(Str,Args) -> + case ct_util:is_silenced(telnet) of + true -> + %% call log/3 now instead of cont_log/2 since + %% start_log/1 will not have been previously called + log("ct_telnet info",Str,Args); + false -> + cont_log(Str,Args) + end. + +%%% @hidden +%% Debug printouts. +debug_cont_log(Str,Args) -> + Old = put(silent,true), + cont_log(Str,Args), + put(silent,Old). + + + +%%%================================================================= +%%% Abstraction layer on top of ct_telnet_client.erl +teln_cmd(Pid,Cmd,Prx,Timeout) -> + ct_telnet_client:send_data(Pid,Cmd), + teln_receive_until_prompt(Pid,Prx,Timeout). + + +teln_get_all_data(Pid,Prx,Data,Acc,LastLine) -> + case check_for_prompt(Prx,lists:reverse(LastLine) ++ Data) of + {prompt,Lines,_PromptType,Rest} -> + teln_get_all_data(Pid,Prx,Rest,[Lines|Acc],[]); + {noprompt,Lines,LastLine1} -> + case ct_telnet_client:get_data(Pid) of + {ok,[]} -> + {ok,lists:reverse(lists:append([Lines|Acc])), + lists:reverse(LastLine1)}; + {ok,Data1} -> + teln_get_all_data(Pid,Prx,Data1,[Lines|Acc],LastLine1) + end + end. + +%% Expect options record +-record(eo,{teln_pid, + prx, + timeout, + haltpatterns=[], + seq=false, + repeat=false, + found_prompt=false}). + +%% @hidden +%% @doc Externally the silent_teln_expect function shall only be used +%% by the TargetModule, i.e. the target specific module which +%% implements connect/2 and get_prompt_regexp/0. +silent_teln_expect(Pid,Data,Pattern,Prx,Opts) -> + Old = put(silent,true), + try_cont_log("silent_teln_expect/5, Pattern = ~p",[Pattern]), + Result = teln_expect(Pid,Data,Pattern,Prx,Opts), + try_cont_log("silent_teln_expect -> ~p\n",[Result]), + put(silent,Old), + Result. + +%% teln_expect/5 +%% +%% This function implements the expect functionality over telnet. In +%% general there are three possible ways to go: +%% 1) Single: One or more patterns are given, and the function return +%% when one of the patterns are matched. +%% 2) Sequence: Several patterns are given, and they are matched in +%% the order they appear in the pattern list. +%% 3a) Repeat (single): 1) is repeated either N times or until a halt +%% condition is fullfilled. +%% 3b) Repeat (sequence): 2) is repeated either N times or until a +%% halt condition is fullfilled. +teln_expect(Pid,Data,Pattern0,Prx,Opts) -> HaltPatterns = case + get_ignore_prompt(Opts) of true -> get_haltpatterns(Opts); false + -> [prompt | get_haltpatterns(Opts)] end, + + Seq = get_seq(Opts), + Pattern = convert_pattern(Pattern0,Seq), + + Timeout = get_timeout(Opts), + + EO = #eo{teln_pid=Pid, + prx=Prx, + timeout=Timeout, + seq=Seq, + haltpatterns=HaltPatterns}, + + case get_repeat(Opts) of + false -> + case teln_expect1(Data,Pattern,[],EO) of + {ok,Matched,Rest} -> + {ok,Matched,Rest}; + {halt,Why,Rest} -> + {error,Why,Rest}; + {error,Reason} -> + {error,Reason} + end; + N -> + EO1 = EO#eo{repeat=N}, + repeat_expect(Data,Pattern,[],EO1) + end. + +convert_pattern(Pattern,Seq) + when is_list(Pattern) and not is_integer(hd(Pattern)) -> + case Seq of + true -> Pattern; + false -> rm_dupl(Pattern,[]) + end; +convert_pattern(Pattern,_Seq) -> + [Pattern]. + +rm_dupl([P|Ps],Acc) -> + case lists:member(P,Acc) of + true -> + rm_dupl(Ps,Acc); + false -> + rm_dupl(Ps,[P|Acc]) + end; +rm_dupl([],Acc) -> + lists:reverse(Acc). + +get_timeout(Opts) -> + case lists:keysearch(timeout,1,Opts) of + {value,{timeout,T}} -> T; + false -> ?DEFAULT_TIMEOUT + end. +get_repeat(Opts) -> + case lists:keysearch(repeat,1,Opts) of + {value,{repeat,N}} when is_integer(N) -> + N; + false -> + case lists:member(repeat,Opts) of + true -> + -1; + false -> + false + end + end. +get_seq(Opts) -> + lists:member(sequence,Opts). +get_haltpatterns(Opts) -> + case lists:keysearch(halt,1,Opts) of + {value,{halt,HaltPatterns}} -> + convert_pattern(HaltPatterns,false); + false -> + [] + end. +get_ignore_prompt(Opts) -> + lists:member(ignore_prompt,Opts). + +%% Repeat either single or sequence. All match results are accumulated +%% and returned when a halt condition is fulllfilled. +repeat_expect(Rest,_Pattern,Acc,#eo{repeat=0}) -> + {ok,lists:reverse(Acc),done,Rest}; +repeat_expect(Data,Pattern,Acc,EO) -> + case teln_expect1(Data,Pattern,[],EO) of + {ok,Matched,Rest} -> + EO1 = EO#eo{repeat=EO#eo.repeat-1}, + repeat_expect(Rest,Pattern,[Matched|Acc],EO1); + {halt,Why,Rest} -> + {ok,lists:reverse(Acc),Why,Rest}; + {error,Reason} -> + {error,Reason} + end. + +teln_expect1(Data,Pattern,Acc,EO) -> + ExpectFun = case EO#eo.seq of + true -> fun() -> seq_expect(Data,Pattern,Acc,EO) end; + false -> fun() -> one_expect(Data,Pattern,EO) end + end, + case ExpectFun() of + {match,Match,Rest} -> + {ok,Match,Rest}; + {halt,Why,Rest} -> + {halt,Why,Rest}; + NotFinished -> + %% Get more data + Fun = fun() -> get_data1(EO#eo.teln_pid) end, + case ct_gen_conn:do_within_time(Fun, EO#eo.timeout) of + {error,Reason} -> + %% A timeout will occur when the telnet connection + %% is idle for EO#eo.timeout milliseconds. + {error,Reason}; + {ok,Data1} -> + case NotFinished of + {nomatch,Rest} -> + %% One expect + teln_expect1(Rest++Data1,Pattern,[],EO); + {continue,Patterns1,Acc1,Rest} -> + %% Sequence + teln_expect1(Rest++Data1,Patterns1,Acc1,EO) + end + end + end. + +get_data1(Pid) -> + case ct_telnet_client:get_data(Pid) of + {ok,[]} -> + get_data1(Pid); + {ok,Data} -> + {ok,Data} + end. + +%% 1) Single expect. +%% First the whole data chunk is searched for a prompt (to avoid doing +%% a regexp match for the prompt at each line). +%% If we are searching for anyting else, the datachunk is split into +%% lines and each line is matched against each pattern. + +%% one_expect: split data chunk at prompts +one_expect(Data,Pattern,EO) -> + case match_prompt(Data,EO#eo.prx) of + {prompt,UptoPrompt,PromptType,Rest} -> + case Pattern of + [Prompt] when Prompt==prompt; Prompt=={prompt,PromptType} -> + %% Only searching for prompt + log_lines(UptoPrompt), + try_cont_log("<b>PROMPT:</b> ~s", [PromptType]), + {match,{prompt,PromptType},Rest}; + [{prompt,_OtherPromptType}] -> + %% Only searching for one specific prompt, not thisone + log_lines(UptoPrompt), + {nomatch,Rest}; + _ -> + one_expect1(UptoPrompt,Pattern,Rest, + EO#eo{found_prompt=PromptType}) + end; + noprompt -> + case Pattern of + [Prompt] when Prompt==prompt; element(1,Prompt)==prompt -> + %% Only searching for prompt + LastLine = log_lines_not_last(Data), + {nomatch,LastLine}; + _ -> + one_expect1(Data,Pattern,[],EO#eo{found_prompt=false}) + end + end. + +remove_zero(List) -> + [Ch || Ch <- List, Ch=/=0, Ch=/=13]. + +%% one_expect1: split data chunk at lines +one_expect1(Data,Pattern,Rest,EO) -> + case match_lines(Data,Pattern,EO) of + {match,Match,MatchRest} -> + {match,Match,MatchRest++Rest}; + {nomatch,prompt} -> + one_expect(Rest,Pattern,EO); + {nomatch,NoMatchRest} -> + {nomatch,NoMatchRest++Rest}; + {halt,Why,HaltRest} -> + {halt,Why,HaltRest++Rest} + end. + + +%% 2) Sequence. +%% First the whole data chunk is searched for a prompt (to avoid doing +%% a regexp match for the prompt at each line). +%% If we are searching for anyting else, the datachunk is split into +%% lines and each line is matched against the first pattern in the list. +%% When a match is found, the match result is accumulated, and we keep +%% searching for the next pattern in the list. + +%% seq_expect: Split data chunk at prompts +seq_expect(Data,[],Acc,_EO) -> + {match,lists:reverse(Acc),Data}; +seq_expect([],Patterns,Acc,_EO) -> + {continue,Patterns,lists:reverse(Acc),[]}; +seq_expect(Data,Patterns,Acc,EO) -> + case match_prompt(Data,EO#eo.prx) of + {prompt,UptoPrompt,PromptType,Rest} -> + seq_expect1(UptoPrompt,Patterns,Acc,Rest, + EO#eo{found_prompt=PromptType}); + noprompt -> + seq_expect1(Data,Patterns,Acc,[],EO#eo{found_prompt=false}) + end. + +%% seq_expect1: For one prompt-chunk, match each pattern - line by +%% line if it is other than the prompt we are seaching for. +seq_expect1(Data,[prompt|Patterns],Acc,Rest,EO) -> + case EO#eo.found_prompt of + false -> + LastLine = log_lines_not_last(Data), + %% Rest==[] because no prompt is found + {continue,[prompt|Patterns],Acc,LastLine}; + PromptType -> + log_lines(Data), + try_cont_log("<b>PROMPT:</b> ~s", [PromptType]), + seq_expect(Rest,Patterns,[{prompt,PromptType}|Acc],EO) + end; +seq_expect1(Data,[{prompt,PromptType}|Patterns],Acc,Rest,EO) -> + case EO#eo.found_prompt of + false -> + LastLine = log_lines_not_last(Data), + %% Rest==[] because no prompt is found + {continue,[{prompt,PromptType}|Patterns],Acc,LastLine}; + PromptType -> + log_lines(Data), + try_cont_log("<b>PROMPT:</b> ~s", [PromptType]), + seq_expect(Rest,Patterns,[{prompt,PromptType}|Acc],EO); + _OtherPromptType -> + log_lines(Data), + seq_expect(Rest,[{prompt,PromptType}|Patterns],Acc,EO) + end; +seq_expect1(Data,[Pattern|Patterns],Acc,Rest,EO) -> + case match_lines(Data,[Pattern],EO) of + {match,Match,MatchRest} -> + seq_expect1(MatchRest,Patterns,[Match|Acc],Rest,EO); + {nomatch,prompt} -> + seq_expect(Rest,[Pattern|Patterns],Acc,EO); + {nomatch,NoMatchRest} when Rest==[] -> + %% The data did not end with a prompt + {continue,[Pattern|Patterns],Acc,NoMatchRest}; + {halt,Why,HaltRest} -> + {halt,Why,HaltRest++Rest} + end; +seq_expect1(Data,[],Acc,Rest,_EO) -> + {match,lists:reverse(Acc),Data++Rest}. + +%% Split prompt-chunk at lines +match_lines(Data,Patterns,EO) -> + FoundPrompt = EO#eo.found_prompt, + case one_line(Data,[]) of + {noline,Rest} when FoundPrompt=/=false -> + %% This is the line including the prompt + case match_line(Rest,Patterns,FoundPrompt,EO) of + nomatch -> + {nomatch,prompt}; + {Tag,Match} -> + {Tag,Match,[]} + end; + {noline,Rest} -> + {nomatch,Rest}; + {Line,Rest} -> + case match_line(Line,Patterns,false,EO) of + nomatch -> + match_lines(Rest,Patterns,EO); + {Tag,Match} -> + {Tag,Match,Rest} + end + end. + + +%% For one line, match each pattern +match_line(Line,Patterns,FoundPrompt,EO) -> + match_line(Line,Patterns,FoundPrompt,EO,match). + +match_line(Line,[prompt|Patterns],false,EO,RetTag) -> + match_line(Line,Patterns,false,EO,RetTag); +match_line(Line,[prompt|_Patterns],FoundPrompt,_EO,RetTag) -> + try_cont_log(" ~s", [Line]), + try_cont_log("<b>PROMPT:</b> ~s", [FoundPrompt]), + {RetTag,{prompt,FoundPrompt}}; +match_line(Line,[{prompt,PromptType}|_Patterns],FoundPrompt,_EO,RetTag) + when PromptType==FoundPrompt -> + try_cont_log(" ~s", [Line]), + try_cont_log("<b>PROMPT:</b> ~s", [FoundPrompt]), + {RetTag,{prompt,FoundPrompt}}; +match_line(Line,[{prompt,PromptType}|Patterns],FoundPrompt,EO,RetTag) + when PromptType=/=FoundPrompt -> + match_line(Line,Patterns,FoundPrompt,EO,RetTag); +match_line(Line,[{Tag,Pattern}|Patterns],FoundPrompt,EO,RetTag) -> + case re:run(Line,Pattern,[{capture,all,list}]) of + nomatch -> + match_line(Line,Patterns,FoundPrompt,EO,RetTag); + {match,Match} -> + try_cont_log("<b>MATCH:</b> ~s", [Line]), + {RetTag,{Tag,Match}} + end; +match_line(Line,[Pattern|Patterns],FoundPrompt,EO,RetTag) -> + case re:run(Line,Pattern,[{capture,all,list}]) of + nomatch -> + match_line(Line,Patterns,FoundPrompt,EO,RetTag); + {match,Match} -> + try_cont_log("<b>MATCH:</b> ~s", [Line]), + {RetTag,Match} + end; +match_line(Line,[],FoundPrompt,EO,match) -> + match_line(Line,EO#eo.haltpatterns,FoundPrompt,EO,halt); +match_line(Line,[],_FoundPrompt,_EO,halt) -> + try_cont_log(" ~s", [Line]), + nomatch. + +one_line([$\n|Rest],Line) -> + {lists:reverse(Line),Rest}; +one_line([$\r|Rest],Line) -> + one_line(Rest,Line); +one_line([0|Rest],Line) -> + one_line(Rest,Line); +one_line([Char|Rest],Line) -> + one_line(Rest,[Char|Line]); +one_line([],Line) -> + {noline,lists:reverse(Line)}. + +debug_log_lines(String) -> + Old = put(silent,true), + log_lines(String), + put(silent,Old). + +log_lines(String) -> + case log_lines_not_last(String) of + [] -> + ok; + LastLine -> + try_cont_log(" ~s", [LastLine]) + end. + +log_lines_not_last(String) -> + case add_tabs(String,[],[]) of + {[],LastLine} -> + LastLine; + {String1,LastLine} -> + try_cont_log("~s",[String1]), + LastLine + end. + +add_tabs([0|Rest],Acc,LastLine) -> + add_tabs(Rest,Acc,LastLine); +add_tabs([$\r|Rest],Acc,LastLine) -> + add_tabs(Rest,Acc,LastLine); +add_tabs([$\n|Rest],Acc,LastLine) -> + add_tabs(Rest,[$\n|LastLine] ++ [$\s,$\s,$\s,$\s,$\s,$\s,$\s|Acc],[]); +add_tabs([Ch|Rest],Acc,LastLine) -> + add_tabs(Rest,Acc,[Ch|LastLine]); +add_tabs([],[$\n|Acc],LastLine) -> + {lists:reverse(Acc),lists:reverse(LastLine)}; +add_tabs([],[],LastLine) -> + {[],lists:reverse(LastLine)}. + + + + +%%% @hidden +teln_receive_until_prompt(Pid,Prx,Timeout) -> + Fun = fun() -> teln_receive_until_prompt(Pid,Prx,[],[]) end, + ct_gen_conn:do_within_time(Fun, Timeout). + +teln_receive_until_prompt(Pid,Prx,Acc,LastLine) -> + {ok,Data} = ct_telnet_client:get_data(Pid), + case check_for_prompt(Prx,LastLine ++ Data) of + {prompt,Lines,PromptType,Rest} -> + Return = lists:reverse(lists:append([Lines|Acc])), + {ok,Return,PromptType,Rest}; + {noprompt,Lines,LastLine1} -> + teln_receive_until_prompt(Pid,Prx,[Lines|Acc],LastLine1) + end. + +check_for_prompt(Prx,Data) -> + case match_prompt(Data,Prx) of + {prompt,UptoPrompt,PromptType,Rest} -> + {RevLines,LastLine} = split_lines(UptoPrompt), + {prompt,[LastLine|RevLines],PromptType,Rest}; + noprompt -> + {RevLines,Rest} = split_lines(Data), + {noprompt,RevLines,Rest} + end. + +split_lines(String) -> + split_lines(String,[],[]). +split_lines([$\n|Rest],Line,Lines) -> + split_lines(Rest,[],[lists:reverse(Line)|Lines]); +split_lines([$\r|Rest],Line,Lines) -> + split_lines(Rest,Line,Lines); +split_lines([0|Rest],Line,Lines) -> + split_lines(Rest,Line,Lines); +split_lines([Char|Rest],Line,Lines) -> + split_lines(Rest,[Char|Line],Lines); +split_lines([],Line,Lines) -> + {Lines,lists:reverse(Line)}. + + +match_prompt(Str,Prx) -> + match_prompt(Str,Prx,[]). +match_prompt(Str,Prx,Acc) -> + case re:run(Str,Prx) of + nomatch -> + noprompt; + {match,[{Start,Len}]} -> + case split_prompt_string(Str,Start+1,Start+Len,1,[],[]) of + {noprompt,Done,Rest} -> + match_prompt(Rest,Prx,Done); + {prompt,UptoPrompt,Prompt,Rest} -> + {prompt,lists:reverse(UptoPrompt++Acc), + lists:reverse(Prompt),Rest} + end + end. + +split_prompt_string([Ch|Str],Start,End,N,UptoPrompt,Prompt) when N<Start -> + split_prompt_string(Str,Start,End,N+1,[Ch|UptoPrompt],Prompt); +split_prompt_string([Ch|Str],Start,End,N,UptoPrompt,Prompt) + when N>=Start, N<End-> + split_prompt_string(Str,Start,End,N+1,UptoPrompt,[Ch|Prompt]); +split_prompt_string([Ch|Rest],_Start,End,N,UptoPrompt,Prompt) when N==End -> + case UptoPrompt of + [$",$=,$T,$P,$M,$O,$R,$P|_] -> + %% This is a line from "listenv", it is not a real prompt + {noprompt,[Ch|Prompt]++UptoPrompt,Rest}; + [$\s,$t,$s,$a|_] when Prompt==":nigol" -> + %% This is probably the "Last login:" statement which is + %% written when telnet connection is openend. + {noprompt,[Ch|Prompt]++UptoPrompt,Rest}; + _ -> + {prompt,[Ch|Prompt]++UptoPrompt,[Ch|Prompt],Rest} + end. diff --git a/lib/common_test/src/ct_telnet_client.erl b/lib/common_test/src/ct_telnet_client.erl new file mode 100644 index 0000000000..e460a50eac --- /dev/null +++ b/lib/common_test/src/ct_telnet_client.erl @@ -0,0 +1,304 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%--------------------------------------------------------------- +%% Basic negotiated options with Telnet (RFC 854) +%% +%% Side A request: I WILL set option Opt. +%% Side B answer: DO go ahead, or no, DON'T set it. +%% +%% Side A request: Please DO set this option. +%% Side B answer: Ok I WILL, or no, I WON'T set it. +%% +%% "Enable option" requests may be rejected. +%% "Disable option" requests must not. +%%--------------------------------------------------------------- + +-module(ct_telnet_client). + +-export([open/1, open/2, open/3, close/1]). +-export([send_data/2, get_data/1]). + +-define(DBG, false). + +-define(TELNET_PORT, 23). +-define(OPEN_TIMEOUT,10000). + +%% telnet control characters +-define(SE, 240). +-define(NOP, 241). +-define(DM, 242). +-define(BRK, 243). +-define(IP, 244). +-define(AO, 245). +-define(AYT, 246). +-define(EC, 247). +-define(EL, 248). +-define(GA, 249). +-define(SB, 250). +-define(WILL, 251). +-define(WONT, 252). +-define(DO, 253). +-define(DONT, 254). +-define(IAC, 255). + +%% telnet options +-define(BINARY, 0). +-define(ECHO, 1). +-define(SUPPRESS_GO_AHEAD, 3). +-define(TERMINAL_TYPE, 24). +-define(WINDOW_SIZE, 31). + +-record(state,{get_data}). + +open(Server) -> + open(Server, ?TELNET_PORT, ?OPEN_TIMEOUT). + +open(Server, Port) -> + open(Server, Port, ?OPEN_TIMEOUT). + +open(Server, Port, Timeout) -> + Self = self(), + Pid = spawn(fun() -> init(Self, Server, Port, Timeout) end), + receive + {open,Pid} -> + {ok,Pid}; + {Error,Pid} -> + Error + end. + +close(Pid) -> + Pid ! close. + +send_data(Pid, Data) -> + Pid ! {send_data, Data++"\n"}, + ok. + +get_data(Pid) -> + Pid ! {get_data, self()}, + receive + {data,Data} -> + {ok, Data} + end. + + +%%%----------------------------------------------------------------- +%%% Internal functions +init(Parent, Server, Port, Timeout) -> + case gen_tcp:connect(Server, Port, [list,{packet,0}], Timeout) of + {ok,Sock} -> + dbg("Connected to: ~p\n", [Server]), + send([?IAC,?DO,?SUPPRESS_GO_AHEAD], Sock), + Parent ! {open,self()}, + loop(#state{get_data=10}, Sock, []), + gen_tcp:close(Sock); + Error -> + Parent ! {Error,self()} + end. + + + +loop(State, Sock, Acc) -> + receive + {tcp_closed,_} -> + dbg("Connection closed\n", []), + receive + {get_data,Pid} -> + Pid ! closed + after 100 -> + ok + end; + {tcp,_,Msg0} -> + dbg("tcp msg: ~p~n",[Msg0]), + Msg = check_msg(Sock,Msg0,[]), + loop(State, Sock, [Msg | Acc]); + {send_data,Data} -> + send(Data, Sock), + loop(State, Sock, Acc); + {get_data,Pid} -> + NewState = + case Acc of + [] -> + dbg("get_data nodata\n",[]), + erlang:send_after(100,self(),{get_data_delayed,Pid}), + State#state{get_data=State#state.get_data - 1}; + _ -> + Pid ! {data,lists:reverse(lists:append(Acc))}, + State + end, + loop(NewState, Sock, []); + {get_data_delayed,Pid} -> + NewState = case State#state.get_data of + 0 -> + send([?IAC,?DO,?NOP], Sock), + dbg("delayed after 1000\n",[]), + State#state{get_data=10}; + _ -> + State + end, + NewAcc = + case erlang:is_process_alive(Pid) of + true -> + Pid ! {data,lists:reverse(lists:append(Acc))}, + []; + false -> + Acc + end, + loop(NewState, Sock, NewAcc); + + close -> + dbg("Closing connection\n", []), + gen_tcp:close(Sock), + ok + after 1000 -> + case Acc of + [] -> % no data buffered + send([?IAC,?DO,?NOP], Sock), + dbg("after 1000\n",[]); + _ -> + true + end, + loop(State, Sock, Acc) + end. + +send(Data, Sock) -> + dbg("Sending: ~p\n", [Data]), + gen_tcp:send(Sock, Data), + ok. + +check_msg(Sock,[?IAC | Cs], Acc) -> + case get_cmd(Cs) of + {Cmd,Cs1} -> + dbg("Got ", []), + cmd_dbg(Cmd), + respond_cmd(Cmd, Sock), + check_msg(Sock, Cs1, Acc); + error -> + Acc + end; +check_msg(Sock,[H|T],Acc) -> + check_msg(Sock,T,[H|Acc]); +check_msg(_Sock,[],Acc) -> + Acc. + +%% Positive responses (WILL and DO). + +respond_cmd([?WILL,?ECHO], Sock) -> + R = [?IAC,?DO,?ECHO], + cmd_dbg(R), + gen_tcp:send(Sock, R); + +respond_cmd([?DO,?ECHO], Sock) -> + R = [?IAC,?WILL,?ECHO], + cmd_dbg(R), + gen_tcp:send(Sock, R); + +%% Answers from server + +respond_cmd([?WILL,?SUPPRESS_GO_AHEAD], _Sock) -> + dbg("Server will suppress-go-ahead\n", []); + +respond_cmd([?WONT,?SUPPRESS_GO_AHEAD], _Sock) -> + dbg("Warning! Server won't suppress-go-ahead\n", []); + +respond_cmd([?DONT | _Opt], _Sock) -> % server ack? + ok; +respond_cmd([?WONT | _Opt], _Sock) -> % server ack? + ok; + +%% Negative responses (WON'T and DON'T). These are default! + +respond_cmd([?WILL,Opt], Sock) -> + R = [?IAC,?DONT,Opt], + cmd_dbg(R), + gen_tcp:send(Sock, R); + +respond_cmd([?DO | Opt], Sock) -> + R = [?IAC,?WONT | Opt], + cmd_dbg(R), + gen_tcp:send(Sock, R); + +%% Unexpected messages. + +respond_cmd([Cmd | Opt], _Sock) when Cmd >= 240, Cmd =< 255 -> + dbg("Received cmd: ~w. Ignored!\n", [[Cmd | Opt]]); + +respond_cmd([Cmd | Opt], _Sock) -> + dbg("WARNING: Received unknown cmd: ~w. Ignored!\n", [[Cmd | Opt]]). + + +get_cmd([Cmd | Rest]) when Cmd == ?SB -> + get_subcmd(Rest, []); + +get_cmd([Cmd,Opt | Rest]) -> + {[Cmd,Opt], Rest}; + +get_cmd(_Other) -> + error. + +get_subcmd([?SE | Rest], Acc) -> + {[?SE | lists:reverse(Acc)], Rest}; + +get_subcmd([Opt | Rest], Acc) -> + get_subcmd(Rest, [Opt | Acc]). + + +dbg(_Str,_Args) -> ok. +% if ?DBG -> io:format(_Str,_Args); +% true -> ok +% end. + +cmd_dbg(_Cmd) -> ok. +% if ?DBG -> +% case _Cmd of +% [?IAC|Cmd1] -> +% cmd_dbg(Cmd1); +% [Ctrl|Opts] -> +% CtrlStr = +% case Ctrl of +% ?DO -> "DO"; +% ?DONT -> "DONT"; +% ?WILL -> "WILL"; +% ?WONT -> "WONT"; +% _ -> "CMD" +% end, +% Opts1 = +% case Opts of +% [Opt] -> Opt; +% _ -> Opts +% end, +% io:format("~s(~w): ~w\n", [CtrlStr,Ctrl,Opts1]); +% Any -> +% io:format("Unexpected in cmd_dbg:~n~w~n",[Any]) +% end; +% true -> ok +% end. + + + + + + + + + + + + + diff --git a/lib/common_test/src/ct_testspec.erl b/lib/common_test/src/ct_testspec.erl new file mode 100644 index 0000000000..21a2f82a54 --- /dev/null +++ b/lib/common_test/src/ct_testspec.erl @@ -0,0 +1,780 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2006-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework functions handlig test specifikations. +%%% +%%% <p>This module exports functions that are used within CT to +%%% scan and parse test specifikations.</p> +-module(ct_testspec). + +-export([prepare_tests/1, prepare_tests/2, + collect_tests_from_list/2, collect_tests_from_list/3, + collect_tests_from_file/2, collect_tests_from_file/3]). + +-include("ct_util.hrl"). + +%%%------------------------------------------------------------------ +%%% NOTE: +%%% Multiple testspecs may be used as input with the result that +%%% the data is merged. It's in this case up to the user to ensure +%%% there are no clashes in any "global" variables, such as logdir. +%%%------------------------------------------------------------------- + +%%%------------------------------------------------------------------- +%%% prepare_tests/2 compiles the testspec data into a list of tests +%%% to be run and a list of tests to be skipped, either for one +%%% particular node or for all nodes. +%%%------------------------------------------------------------------- + +%%%------------------------------------------------------------------- +%%% Version 1 - extract and return all tests and skips for Node +%%% (incl all_nodes) +%%%------------------------------------------------------------------- +prepare_tests(TestSpec,Node) when is_record(TestSpec,testspec), is_atom(Node) -> + case lists:keysearch(Node,1,prepare_tests(TestSpec)) of + {value,{Node,Run,Skip}} -> + {Run,Skip}; + false -> + {[],[]} + end. + +%%%------------------------------------------------------------------- +%%% Version 2 - create and return a list of {Node,Run,Skip} tuples, +%%% one for each node specified in the test specification. +%%% The tuples in the Run list will have the form {Dir,Suites,Cases} +%%% and the tuples in the Skip list will have the form +%%% {Dir,Suites,Comment} or {Dir,Suite,Cases,Comment}. +%%%------------------------------------------------------------------- +prepare_tests(TestSpec) when is_record(TestSpec,testspec) -> + Tests = TestSpec#testspec.tests, + %% Sort Tests into "flat" Run and Skip lists (not sorted per node). + {Run,Skip} = get_run_and_skip(Tests,[],[]), + %% Create initial list of {Node,{Run,Skip}} tuples + NodeList = lists:map(fun(N) -> {N,{[],[]}} end, list_nodes(TestSpec)), + %% Get all Run tests sorted per node basis. + NodeList1 = run_per_node(Run,NodeList), + %% Get all Skip entries sorted per node basis. + NodeList2 = skip_per_node(Skip,NodeList1), + %% Change representation. + Result= + lists:map(fun({Node,{Run1,Skip1}}) -> + Run2 = lists:map(fun({D,{Ss,Cs}}) -> + {D,Ss,Cs} + end, Run1), + Skip2 = lists:map(fun({D,{Ss,Cmt}}) -> + {D,Ss,Cmt}; + ({D,{S,Cs,Cmt}}) -> + {D,S,Cs,Cmt} + end, Skip1), + {Node,Run2,Skip2} + end, NodeList2), + Result. + +%% run_per_node/2 takes the Run list as input and returns a list +%% of {Node,RunPerNode,[]} tuples where the tests have been sorted +%% on a per node basis. +run_per_node([{{Node,Dir},Test}|Ts],Result) -> + {value,{Node,{Run,Skip}}} = lists:keysearch(Node,1,Result), + Run1 = merge_tests(Dir,Test,Run), + run_per_node(Ts,insert_in_order({Node,{Run1,Skip}},Result)); +run_per_node([],Result) -> + Result. + +merge_tests(Dir,Test={all,_},TestDirs) -> + %% overwrite all previous entries for Dir + TestDirs1 = lists:filter(fun({D,_}) when D==Dir -> + false; + (_) -> + true + end,TestDirs), + insert_in_order({Dir,Test},TestDirs1); +merge_tests(Dir,Test={Suite,all},TestDirs) -> + TestDirs1 = lists:filter(fun({D,{S,_}}) when D==Dir,S==Suite -> + false; + (_) -> + true + end,TestDirs), + TestDirs1++[{Dir,Test}]; +merge_tests(Dir,Test,TestDirs) -> + merge_suites(Dir,Test,TestDirs). + +merge_suites(Dir,{Suite,Cases},[{Dir,{Suite,Cases0}}|Dirs]) -> + Cases1 = insert_in_order(Cases,Cases0), + [{Dir,{Suite,Cases1}}|Dirs]; +merge_suites(Dir,Test,[Other|Dirs]) -> + [Other|merge_suites(Dir,Test,Dirs)]; +merge_suites(Dir,Test,[]) -> + [{Dir,Test}]. + +%% skip_per_node/2 takes the Skip list as input and returns a list +%% of {Node,RunPerNode,SkipPerNode} tuples where the skips have been +%% sorted on a per node basis. +skip_per_node([{{Node,Dir},Test}|Ts],Result) -> + {value,{Node,{Run,Skip}}} = lists:keysearch(Node,1,Result), + Skip1 = [{Dir,Test}|Skip], + skip_per_node(Ts,insert_in_order({Node,{Run,Skip1}},Result)); +skip_per_node([],Result) -> + Result. + +%% get_run_and_skip/3 takes a list of test terms as input and sorts +%% them into a list of Run tests and a list of Skip entries. The +%% elements all have the form +%% +%% {{Node,Dir},TestData} +%% +%% TestData has the form: +%% +%% Run entry: {Suite,Cases} +%% +%% Skip entry: {Suites,Comment} or {Suite,Cases,Comment} +%% +get_run_and_skip([{{Node,Dir},Suites}|Tests],Run,Skip) -> + TestDir = ct_util:get_testdir(Dir,catch element(1,hd(Suites))), + case lists:keysearch(all,1,Suites) of + {value,_} -> % all Suites in Dir + Skipped = get_skipped_suites(Node,TestDir,Suites), + %% note: this adds an 'all' test even if only skip is specified, + %% probably a good thing cause it gets logged as skipped then + get_run_and_skip(Tests, + [[{{Node,TestDir},{all,all}}]|Run], + [Skipped|Skip]); + false -> + {R,S} = prepare_suites(Node,TestDir,Suites,[],[]), + get_run_and_skip(Tests,[R|Run],[S|Skip]) + end; +get_run_and_skip([],Run,Skip) -> + {lists:flatten(lists:reverse(Run)), + lists:flatten(lists:reverse(Skip))}. + +prepare_suites(Node,Dir,[{Suite,Cases}|Suites],Run,Skip) -> + case lists:member(all,Cases) of + true -> % all Cases in Suite + Skipped = get_skipped_cases(Node,Dir,Suite,Cases), + %% note: this adds an 'all' test even if only skip is specified + prepare_suites(Node,Dir,Suites, + [[{{Node,Dir},{Suite,all}}]|Run], + [Skipped|Skip]); + false -> + {RL,SL} = prepare_cases(Node,Dir,Suite,Cases), + prepare_suites(Node,Dir,Suites,[RL|Run],[SL|Skip]) + end; +prepare_suites(_Node,_Dir,[],Run,Skip) -> + {lists:flatten(lists:reverse(Run)), + lists:flatten(lists:reverse(Skip))}. + +prepare_cases(Node,Dir,Suite,Cases) -> + case get_skipped_cases(Node,Dir,Suite,Cases) of + SkipAll=[{{Node,Dir},{Suite,_Cmt}}] -> % all cases to be skipped + %% note: this adds an 'all' test even if only skip is specified + {[{{Node,Dir},{Suite,all}}],SkipAll}; + Skipped -> + %% note: this adds a test even if only skip is specified + PrepC = lists:foldr(fun({C,{skip,_Cmt}},Acc) -> + case lists:member(C,Cases) of + true -> + Acc; + false -> + [C|Acc] + end; + (C,Acc) -> [C|Acc] + end, [], Cases), + {{{Node,Dir},{Suite,PrepC}},Skipped} + end. + +get_skipped_suites(Node,Dir,Suites) -> + lists:flatten(get_skipped_suites1(Node,Dir,Suites)). + +get_skipped_suites1(Node,Dir,[{Suite,Cases}|Suites]) -> + SkippedCases = get_skipped_cases(Node,Dir,Suite,Cases), + [SkippedCases|get_skipped_suites1(Node,Dir,Suites)]; +get_skipped_suites1(_,_,[]) -> + []. + +get_skipped_cases(Node,Dir,Suite,Cases) -> + case lists:keysearch(all,1,Cases) of + {value,{all,{skip,Cmt}}} -> + [{{Node,Dir},{Suite,Cmt}}]; + false -> + get_skipped_cases1(Node,Dir,Suite,Cases) + end. + +get_skipped_cases1(Node,Dir,Suite,[{Case,{skip,Cmt}}|Cs]) -> + [{{Node,Dir},{Suite,Case,Cmt}}|get_skipped_cases1(Node,Dir,Suite,Cs)]; +get_skipped_cases1(Node,Dir,Suite,[_Case|Cs]) -> + get_skipped_cases1(Node,Dir,Suite,Cs); +get_skipped_cases1(_,_,_,[]) -> + []. + +%%% collect_tests_from_file reads a testspec file and returns a record +%%% containing the data found. +collect_tests_from_file(Specs, Relaxed) -> + collect_tests_from_file(Specs,[node()],Relaxed). + +collect_tests_from_file(Specs,Nodes,Relaxed) when is_list(Nodes) -> + NodeRefs = lists:map(fun(N) -> {undefined,N} end, Nodes), + catch collect_tests_from_file1(Specs,#testspec{nodes=NodeRefs},Relaxed). + +collect_tests_from_file1([Spec|Specs],TestSpec,Relaxed) -> + case file:consult(Spec) of + {ok,Terms} -> + TestSpec1 = collect_tests(Terms,TestSpec,Relaxed), + collect_tests_from_file1(Specs,TestSpec1,Relaxed); + {error,Reason} -> + throw({error,{Spec,Reason}}) + end; +collect_tests_from_file1([],TS=#testspec{config=Cfgs,event_handler=EvHs, + include=Incl,tests=Tests},_) -> + TS#testspec{config=lists:reverse(Cfgs), + event_handler=lists:reverse(EvHs), + include=lists:reverse(Incl), + tests=lists:flatten(Tests)}. + +collect_tests_from_list(Terms,Relaxed) -> + collect_tests_from_list(Terms,[node()],Relaxed). + +collect_tests_from_list(Terms,Nodes,Relaxed) when is_list(Nodes) -> + NodeRefs = lists:map(fun(N) -> {undefined,N} end, Nodes), + case catch collect_tests(Terms,#testspec{nodes=NodeRefs},Relaxed) of + E = {error,_} -> + E; + TS -> + #testspec{config=Cfgs,event_handler=EvHs,include=Incl,tests=Tests} = TS, + TS#testspec{config=lists:reverse(Cfgs), + event_handler=lists:reverse(EvHs), + include=lists:reverse(Incl), + tests=lists:flatten(Tests)} + end. + +collect_tests(Terms,TestSpec,Relaxed) -> + put(relaxed,Relaxed), + TestSpec1 = get_global(Terms,TestSpec), + TestSpec2 = get_all_nodes(Terms,TestSpec1), + add_tests(Terms,TestSpec2). + +get_global([{alias,Ref,Dir}|Ts],Spec=#testspec{alias=Refs}) -> + get_global(Ts,Spec#testspec{alias=[{Ref,get_absname(Dir)}|Refs]}); +get_global([{node,Ref,Node}|Ts],Spec=#testspec{nodes=Refs}) -> + get_global(Ts,Spec#testspec{nodes=[{Ref,Node}|lists:keydelete(Node,2,Refs)]}); +get_global([_|Ts],Spec) -> get_global(Ts,Spec); +get_global([],Spec) -> Spec. + +get_absname(TestDir) -> + AbsName = filename:absname(TestDir), + TestDirName = filename:basename(AbsName), + Path = filename:dirname(AbsName), + TopDir = filename:basename(Path), + Path1 = + case TopDir of + "." -> + [_|Rev] = lists:reverse(filename:split(Path)), + filename:join(lists:reverse(Rev)); + ".." -> + [_,_|Rev] = lists:reverse(filename:split(Path)), + filename:join(lists:reverse(Rev)); + _ -> + Path + end, + filename:join(Path1,TestDirName). + +%% go through all tests and register all nodes found +get_all_nodes([{suites,Nodes,_,_}|Ts],Spec) when is_list(Nodes) -> + get_all_nodes(Ts,save_nodes(Nodes,Spec)); +get_all_nodes([{suites,Node,_,_}|Ts],Spec) -> + get_all_nodes(Ts,save_nodes([Node],Spec)); +get_all_nodes([{cases,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) -> + get_all_nodes(Ts,save_nodes(Nodes,Spec)); +get_all_nodes([{cases,Node,_,_,_}|Ts],Spec) -> + get_all_nodes(Ts,save_nodes([Node],Spec)); +get_all_nodes([{skip_suites,Nodes,_,_,_}|Ts],Spec) when is_list(Nodes) -> + get_all_nodes(Ts,save_nodes(Nodes,Spec)); +get_all_nodes([{skip_suites,Node,_,_,_}|Ts],Spec) -> + get_all_nodes(Ts,save_nodes([Node],Spec)); +get_all_nodes([{skip_cases,Nodes,_,_,_,_}|Ts],Spec) when is_list(Nodes) -> + get_all_nodes(Ts,save_nodes(Nodes,Spec)); +get_all_nodes([{skip_cases,Node,_,_,_,_}|Ts],Spec) -> + get_all_nodes(Ts,save_nodes([Node],Spec)); +get_all_nodes([_|Ts],Spec) -> + get_all_nodes(Ts,Spec); +get_all_nodes([],Spec) -> + Spec. + +save_nodes(Nodes,Spec=#testspec{nodes=NodeRefs}) -> + NodeRefs1 = + lists:foldr(fun(all_nodes,NR) -> + NR; + (Node,NR) -> + case lists:keymember(Node,1,NR) of + true -> + NR; + false -> + case lists:keymember(Node,2,NR) of + true -> + NR; + false -> + [{undefined,Node}|NR] + end + end + end,NodeRefs,Nodes), + Spec#testspec{nodes=NodeRefs1}. + +list_nodes(#testspec{nodes=NodeRefs}) -> + lists:map(fun({_Ref,Node}) -> Node end, NodeRefs). + +%% Associate a "global" logdir with all nodes +%% except those with specific logdir, e.g: +%% ["/tmp/logdir",{ct1@finwe,"/tmp/logdir2"}] +%% means all nodes should write to /tmp/logdir +%% except ct1@finwe that should use /tmp/logdir2. + +%% --- logdir --- +add_tests([{logdir,all_nodes,Dir}|Ts],Spec) -> + Dirs = Spec#testspec.logdir, + Tests = [{logdir,N,Dir} || N <- list_nodes(Spec), + lists:keymember(ref2node(N,Spec#testspec.nodes), + 1,Dirs) == false], + add_tests(Tests++Ts,Spec); +add_tests([{logdir,Nodes,Dir}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,logdir,[Dir],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{logdir,Node,Dir}|Ts],Spec) -> + Dirs = Spec#testspec.logdir, + Dirs1 = [{ref2node(Node,Spec#testspec.nodes),Dir} | + lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,Dirs)], + add_tests(Ts,Spec#testspec{logdir=Dirs1}); +add_tests([{logdir,Dir}|Ts],Spec) -> + add_tests([{logdir,all_nodes,Dir}|Ts],Spec); + +%% --- cover --- +add_tests([{cover,all_nodes,File}|Ts],Spec) -> + Tests = lists:map(fun(N) -> {cover,N,File} end, list_nodes(Spec)), + add_tests(Tests++Ts,Spec); +add_tests([{cover,Nodes,File}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,cover,[File],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{cover,Node,File}|Ts],Spec) -> + CoverFs = Spec#testspec.cover, + CoverFs1 = [{ref2node(Node,Spec#testspec.nodes),File} | + lists:keydelete(ref2node(Node,Spec#testspec.nodes),1,CoverFs)], + add_tests(Ts,Spec#testspec{cover=CoverFs1}); +add_tests([{cover,File}|Ts],Spec) -> + add_tests([{cover,all_nodes,File}|Ts],Spec); + +%% --- config --- +add_tests([{config,all_nodes,Files}|Ts],Spec) -> + Tests = lists:map(fun(N) -> {config,N,Files} end, list_nodes(Spec)), + add_tests(Tests++Ts,Spec); +add_tests([{config,Nodes,Files}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,config,[Files],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{config,Node,[F|Fs]}|Ts],Spec) when is_list(F) -> + Cfgs = Spec#testspec.config, + Node1 = ref2node(Node,Spec#testspec.nodes), + add_tests([{config,Node,Fs}|Ts],Spec#testspec{config=[{Node1,F}|Cfgs]}); +add_tests([{config,_Node,[]}|Ts],Spec) -> + add_tests(Ts,Spec); +add_tests([{config,Node,F}|Ts],Spec) -> + add_tests([{config,Node,[F]}|Ts],Spec); +add_tests([{config,Files}|Ts],Spec) -> + add_tests([{config,all_nodes,Files}|Ts],Spec); + +%% --- event_handler --- +add_tests([{event_handler,all_nodes,Hs}|Ts],Spec) -> + Tests = lists:map(fun(N) -> {event_handler,N,Hs,[]} end, list_nodes(Spec)), + add_tests(Tests++Ts,Spec); +add_tests([{event_handler,all_nodes,Hs,Args}|Ts],Spec) when is_list(Args) -> + Tests = lists:map(fun(N) -> {event_handler,N,Hs,Args} end, list_nodes(Spec)), + add_tests(Tests++Ts,Spec); +add_tests([{event_handler,Hs}|Ts],Spec) -> + add_tests([{event_handler,all_nodes,Hs,[]}|Ts],Spec); +add_tests([{event_handler,HsOrNodes,HsOrArgs}|Ts],Spec) -> + case is_noderef(HsOrNodes,Spec#testspec.nodes) of + true -> % HsOrNodes == Nodes, HsOrArgs == Hs + case {HsOrNodes,HsOrArgs} of + {Nodes,Hs} when is_list(Nodes) -> + Ts1 = separate(Nodes,event_handler,[Hs,[]],Ts, + Spec#testspec.nodes), + add_tests(Ts1,Spec); + {_Node,[]} -> + add_tests(Ts,Spec); + {Node,HOrHs} -> + EvHs = Spec#testspec.event_handler, + Node1 = ref2node(Node,Spec#testspec.nodes), + case HOrHs of + [H|Hs] when is_atom(H) -> + add_tests([{event_handler,Node,Hs}|Ts], + Spec#testspec{event_handler=[{Node1,H,[]}|EvHs]}); + H when is_atom(H) -> + add_tests(Ts,Spec#testspec{event_handler=[{Node1,H,[]}|EvHs]}) + end + end; + false -> % HsOrNodes == Hs, HsOrArgs == Args + add_tests([{event_handler,all_nodes,HsOrNodes,HsOrArgs}|Ts],Spec) + end; +add_tests([{event_handler,Nodes,Hs,Args}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,event_handler,[Hs,Args],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{event_handler,Node,[H|Hs],Args}|Ts],Spec) when is_atom(H) -> + EvHs = Spec#testspec.event_handler, + Node1 = ref2node(Node,Spec#testspec.nodes), + add_tests([{event_handler,Node,Hs,Args}|Ts], + Spec#testspec{event_handler=[{Node1,H,Args}|EvHs]}); +add_tests([{event_handler,_Node,[],_Args}|Ts],Spec) -> + add_tests(Ts,Spec); +add_tests([{event_handler,Node,H,Args}|Ts],Spec) when is_atom(H) -> + EvHs = Spec#testspec.event_handler, + Node1 = ref2node(Node,Spec#testspec.nodes), + add_tests(Ts,Spec#testspec{event_handler=[{Node1,H,Args}|EvHs]}); + +%% --- include --- +add_tests([{include,all_nodes,InclDirs}|Ts],Spec) -> + Tests = lists:map(fun(N) -> {include,N,InclDirs} end, list_nodes(Spec)), + add_tests(Tests++Ts,Spec); +add_tests([{include,Nodes,InclDirs}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,include,[InclDirs],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{include,Node,[D|Ds]}|Ts],Spec) when is_list(D) -> + Dirs = Spec#testspec.include, + Node1 = ref2node(Node,Spec#testspec.nodes), + add_tests([{include,Node,Ds}|Ts],Spec#testspec{include=[{Node1,D}|Dirs]}); +add_tests([{include,_Node,[]}|Ts],Spec) -> + add_tests(Ts,Spec); +add_tests([{include,Node,D}|Ts],Spec) -> + add_tests([{include,Node,[D]}|Ts],Spec); +add_tests([{include,InclDirs}|Ts],Spec) -> + add_tests([{include,all_nodes,InclDirs}|Ts],Spec); + +%% --- suites --- +add_tests([{suites,all_nodes,Dir,Ss}|Ts],Spec) -> + add_tests([{suites,list_nodes(Spec),Dir,Ss}|Ts],Spec); +add_tests([{suites,Dir,Ss}|Ts],Spec) -> + add_tests([{suites,all_nodes,Dir,Ss}|Ts],Spec); +add_tests([{suites,Nodes,Dir,Ss}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,suites,[Dir,Ss],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{suites,Node,Dir,Ss}|Ts],Spec) -> + Tests = Spec#testspec.tests, + Tests1 = insert_suites(ref2node(Node,Spec#testspec.nodes), + ref2dir(Dir,Spec#testspec.alias), + Ss,Tests), + add_tests(Ts,Spec#testspec{tests=Tests1}); + +%% --- cases --- +add_tests([{cases,all_nodes,Dir,Suite,Cs}|Ts],Spec) -> + add_tests([{cases,list_nodes(Spec),Dir,Suite,Cs}|Ts],Spec); +add_tests([{cases,Dir,Suite,Cs}|Ts],Spec) -> + add_tests([{cases,all_nodes,Dir,Suite,Cs}|Ts],Spec); +add_tests([{cases,Nodes,Dir,Suite,Cs}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,cases,[Dir,Suite,Cs],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{cases,Node,Dir,Suite,Cs}|Ts],Spec) -> + Tests = Spec#testspec.tests, + Tests1 = insert_cases(ref2node(Node,Spec#testspec.nodes), + ref2dir(Dir,Spec#testspec.alias), + Suite,Cs,Tests), + add_tests(Ts,Spec#testspec{tests=Tests1}); + +%% --- skip_suites --- +add_tests([{skip_suites,all_nodes,Dir,Ss,Cmt}|Ts],Spec) -> + add_tests([{skip_suites,list_nodes(Spec),Dir,Ss,Cmt}|Ts],Spec); +add_tests([{skip_suites,Dir,Ss,Cmt}|Ts],Spec) -> + add_tests([{skip_suites,all_nodes,Dir,Ss,Cmt}|Ts],Spec); +add_tests([{skip_suites,Nodes,Dir,Ss,Cmt}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,skip_suites,[Dir,Ss,Cmt],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{skip_suites,Node,Dir,Ss,Cmt}|Ts],Spec) -> + Tests = Spec#testspec.tests, + Tests1 = skip_suites(ref2node(Node,Spec#testspec.nodes), + ref2dir(Dir,Spec#testspec.alias), + Ss,Cmt,Tests), + add_tests(Ts,Spec#testspec{tests=Tests1}); + +%% --- skip_cases --- +add_tests([{skip_cases,all_nodes,Dir,Suite,Cs,Cmt}|Ts],Spec) -> + add_tests([{skip_cases,list_nodes(Spec),Dir,Suite,Cs,Cmt}|Ts],Spec); +add_tests([{skip_cases,Dir,Suite,Cs,Cmt}|Ts],Spec) -> + add_tests([{skip_cases,all_nodes,Dir,Suite,Cs,Cmt}|Ts],Spec); +add_tests([{skip_cases,Nodes,Dir,Suite,Cs,Cmt}|Ts],Spec) when is_list(Nodes) -> + Ts1 = separate(Nodes,skip_cases,[Dir,Suite,Cs,Cmt],Ts,Spec#testspec.nodes), + add_tests(Ts1,Spec); +add_tests([{skip_cases,Node,Dir,Suite,Cs,Cmt}|Ts],Spec) -> + Tests = Spec#testspec.tests, + Tests1 = skip_cases(ref2node(Node,Spec#testspec.nodes), + ref2dir(Dir,Spec#testspec.alias), + Suite,Cs,Cmt,Tests), + add_tests(Ts,Spec#testspec{tests=Tests1}); + +%% --- handled/errors --- +add_tests([{alias,_,_}|Ts],Spec) -> % handled + add_tests(Ts,Spec); + +add_tests([{node,_,_}|Ts],Spec) -> % handled + add_tests(Ts,Spec); + +%% check if it's a CT term that has bad format or if the user seems to +%% have added something of his/her own, which we'll let pass if relaxed +%% mode is enabled. +add_tests([Other|Ts],Spec) when is_tuple(Other) -> + [Name|_] = tuple_to_list(Other), + case lists:keymember(Name,1,valid_terms()) of + true -> % halt + throw({error,{bad_term_in_spec,Other}}); + false -> % ignore + case get(relaxed) of + true -> + %% warn if name resembles a CT term + case resembles_ct_term(Name,size(Other)) of + true -> + io:format("~nSuspicious term, please check:~n" + "~p~n", [Other]); + false -> + ok + end, + add_tests(Ts,Spec); + false -> + throw({error,{undefined_term_in_spec,Other}}) + end + end; + +add_tests([Other|Ts],Spec) -> + case get(relaxed) of + true -> + add_tests(Ts,Spec); + false -> + throw({error,{undefined_term_in_spec,Other}}) + end; + +add_tests([],Spec) -> % done + Spec. + +separate(Nodes,Tag,Data,Tests,Refs) -> + Separated = separate(Nodes,Tag,Data,Refs), + Separated ++ Tests. +separate([N|Ns],Tag,Data,Refs) -> + [list_to_tuple([Tag,ref2node(N,Refs)|Data])|separate(Ns,Tag,Data,Refs)]; +separate([],_,_,_) -> + []. + + +%% Representation: +%% {{Node,Dir},[{Suite1,[case11,case12,...]},{Suite2,[case21,case22,...]},...]} +%% {{Node,Dir},[{Suite1,{skip,Cmt}},{Suite2,[{case21,{skip,Cmt}},case22,...]},...]} + +insert_suites(Node,Dir,[S|Ss],Tests) -> + Tests1 = insert_cases(Node,Dir,S,all,Tests), + insert_suites(Node,Dir,Ss,Tests1); +insert_suites(_Node,_Dir,[],Tests) -> + Tests; +insert_suites(Node,Dir,S,Tests) -> + insert_suites(Node,Dir,[S],Tests). + +insert_cases(Node,Dir,Suite,Cases,Tests) when is_list(Cases) -> + case lists:keysearch({Node,Dir},1,Tests) of + {value,{{Node,Dir},[{all,_}]}} -> + Tests; + {value,{{Node,Dir},Suites0}} -> + Suites1 = insert_cases1(Suite,Cases,Suites0), + insert_in_order({{Node,Dir},Suites1},Tests); + false -> + insert_in_order({{Node,Dir},[{Suite,Cases}]},Tests) + end; +insert_cases(Node,Dir,Suite,Case,Tests) when is_atom(Case) -> + insert_cases(Node,Dir,Suite,[Case],Tests). + +insert_cases1(_Suite,_Cases,all) -> + all; +insert_cases1(Suite,Cases,Suites0) -> + case lists:keysearch(Suite,1,Suites0) of + {value,{Suite,all}} -> + Suites0; + {value,{Suite,Cases0}} -> + Cases1 = insert_in_order(Cases,Cases0), + insert_in_order({Suite,Cases1},Suites0); + false -> + insert_in_order({Suite,Cases},Suites0) + end. + +skip_suites(Node,Dir,[S|Ss],Cmt,Tests) -> + Tests1 = skip_cases(Node,Dir,S,all,Cmt,Tests), + skip_suites(Node,Dir,Ss,Cmt,Tests1); +skip_suites(_Node,_Dir,[],_Cmt,Tests) -> + Tests; +skip_suites(Node,Dir,S,Cmt,Tests) -> + skip_suites(Node,Dir,[S],Cmt,Tests). + +skip_cases(Node,Dir,Suite,Cases,Cmt,Tests) when is_list(Cases) -> + Suites = + case lists:keysearch({Node,Dir},1,Tests) of + {value,{{Node,Dir},Suites0}} -> + Suites0; + false -> + [] + end, + Suites1 = skip_cases1(Suite,Cases,Cmt,Suites), + insert_in_order({{Node,Dir},Suites1},Tests); +skip_cases(Node,Dir,Suite,Case,Cmt,Tests) when is_atom(Case) -> + skip_cases(Node,Dir,Suite,[Case],Cmt,Tests). + +skip_cases1(Suite,Cases,Cmt,Suites0) -> + SkipCases = lists:map(fun(C) -> + {C,{skip,Cmt}} + end,Cases), + case lists:keysearch(Suite,1,Suites0) of + {value,{Suite,Cases0}} -> + Cases1 = Cases0 ++ SkipCases, + insert_in_order({Suite,Cases1},Suites0); + false -> + insert_in_order({Suite,SkipCases},Suites0) + end. + +insert_in_order([E|Es],List) -> + List1 = insert_elem(E,List,[]), + insert_in_order(Es,List1); +insert_in_order([],List) -> + List; +insert_in_order(E,List) -> + insert_elem(E,List,[]). + +%% replace an existing entry (same key) or add last in list +insert_elem({Key,_}=E,[{Key,_}|Rest],SoFar) -> + lists:reverse([E|SoFar]) ++ Rest; +insert_elem({E,_},[E|Rest],SoFar) -> + lists:reverse([E|SoFar]) ++ Rest; +insert_elem(E,[E|Rest],SoFar) -> + lists:reverse([E|SoFar]) ++ Rest; +insert_elem(E,[E1|Rest],SoFar) -> + insert_elem(E,Rest,[E1|SoFar]); +insert_elem(E,[],SoFar) -> + lists:reverse([E|SoFar]). + +ref2node(all_nodes,_Refs) -> + all_nodes; +ref2node(master,_Refs) -> + master; +ref2node(RefOrNode,Refs) -> + case string:chr(atom_to_list(RefOrNode),$@) of + 0 -> % a ref + case lists:keysearch(RefOrNode,1,Refs) of + {value,{RefOrNode,Node}} -> + Node; + false -> + throw({error,{noderef_missing,RefOrNode}}) + end; + _ -> % a node + RefOrNode + end. + +ref2dir(Ref,Refs) when is_atom(Ref) -> + case lists:keysearch(Ref,1,Refs) of + {value,{Ref,Dir}} -> + Dir; + false -> + throw({error,{alias_missing,Ref}}) + end; +ref2dir(Dir,_) when is_list(Dir) -> + Dir. + +is_noderef(What,Nodes) when is_atom(What) -> + is_noderef([What],Nodes); +is_noderef([master|_],_Nodes) -> + true; +is_noderef([What|_],Nodes) -> + case lists:keymember(What,1,Nodes) or + lists:keymember(What,2,Nodes) of + true -> + true; + false -> + false + end; +is_noderef([],_) -> + false. + +valid_terms() -> + [ + {node,3}, + {cover,2}, + {cover,3}, + {config,2}, + {config,3}, + {alias,3}, + {logdir,2}, + {logdir,3}, + {event_handler,2}, + {event_handler,3}, + {event_handler,4}, + {include,2}, + {include,3}, + + {suites,3}, + {suites,4}, + {cases,4}, + {cases,5}, + {skip_suites,4}, + {skip_suites,5}, + {skip_cases,5}, + {skip_cases,6} + ]. + +%% this function "guesses" if the user has misspelled a term name +resembles_ct_term(Name,Size) when is_atom(Name) -> + resembles_ct_term2(atom_to_list(Name),Size); +resembles_ct_term(_Name,_) -> + false. + +resembles_ct_term2(Name,Size) when length(Name) > 3 -> + CTTerms = [{atom_to_list(Tag),Sz} || {Tag,Sz} <- valid_terms()], + compare_names(Name,Size,CTTerms); +resembles_ct_term2(_,_) -> + false. + +compare_names(Name,Size,[{Term,Sz}|Ts]) -> + if abs(Size-Sz) > 0 -> + compare_names(Name,Size,Ts); + true -> + Diff = abs(length(Name)-length(Term)), + if Diff > 1 -> + compare_names(Name,Size,Ts); + true -> + Common = common_letters(Name,Term,0), + Bad = abs(length(Name)-Common), + if Bad > 2 -> + compare_names(Name,Size,Ts); + true -> + true + end + end + end; +compare_names(_,_,[]) -> + false. + +common_letters(_,[],Count) -> + Count; +common_letters([L|Ls],Term,Count) -> + case lists:member(L,Term) of + true -> + Term1 = lists:delete(L,Term), + common_letters(Ls,Term1,Count+1); + false -> + common_letters(Ls,Term,Count) + end; +common_letters([],_,Count) -> + Count. + + + + diff --git a/lib/common_test/src/ct_util.erl b/lib/common_test/src/ct_util.erl new file mode 100644 index 0000000000..ba3d789f8d --- /dev/null +++ b/lib/common_test/src/ct_util.erl @@ -0,0 +1,1303 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Common Test Framework Utilities. +%%% +%%% <p>This is a support module for the Common Test Framework. It +%%% implements the process ct_util_server which acts like a data +%%% holder for suite, configuration and connection data.</p> +%%% +-module(ct_util). + +-export([start/0,start/1,start/2,stop/1,update_last_run_index/0]). + +-export([register_connection/4,unregister_connection/1, + does_connection_exist/3,get_key_from_name/1]). + +-export([require/1, require/2, get_config/1, get_config/2, get_config/3, + set_default_config/2, set_default_config/3, delete_default_config/1, + get_all_config/0, update_config/2, + release_allocated/0, close_connections/0]). + +-export([save_suite_data/3, save_suite_data/2, read_suite_data/1, + delete_suite_data/0, delete_suite_data/1, match_delete_suite_data/1, + delete_testdata/0, delete_testdata/1, set_testdata/1, get_testdata/1, + update_testdata/2]). + +-export([override_silence_all_connections/0, override_silence_connections/1, + get_overridden_silenced_connections/0, + delete_overridden_silenced_connections/0, + silence_all_connections/0, silence_connections/1, is_silenced/1, + reset_silent_connections/0]). + +-export([set_cwd/1, reset_cwd/0]). + +-export([parse_table/1]). + +-export([listenv/1]). + +-export([get_target_name/1, get_connections/2]). + +-export([is_test_dir/1, get_testdir/2]). + +-export([encrypt_config_file/2, encrypt_config_file/3, + decrypt_config_file/2, decrypt_config_file/3]). + +-export([kill_attached/2, get_attached/1]). + +-export([warn_duplicates/1]). + +-include("ct_event.hrl"). +-include("ct_util.hrl"). + +-record(ct_conf,{key,value,ref,name='_UNDEF',default=false}). +%% default = {true,suite} | {true,testcase} | false + +-record(suite_data, {key,name,value}). + +-define(cryptfile, ".ct_config.crypt"). + +%%%----------------------------------------------------------------- +%%% @spec start(Mode) -> Pid | exit(Error) +%%% Mode = normal | interactive +%%% Pid = pid() +%%% +%%% @doc Start start the ct_util_server process +%%% (tool-internal use only). +%%% +%%% <p>This function is called from ct_run.erl. It starts and initiates +%%% the <code>ct_util_server</code></p> +%%% +%%% <p>Returns the process identity of the +%%% <code>ct_util_server</code>.</p> +%%% +%%% @see ct +start() -> + start(normal,"."). + +start(LogDir) when is_list(LogDir) -> + start(normal,LogDir); +start(Mode) -> + start(Mode,"."). + +start(Mode,LogDir) -> + case whereis(ct_util_server) of + undefined -> + S = self(), + Pid = spawn_link(fun() -> do_start(S,Mode,LogDir) end), + receive + {Pid,started} -> Pid; + {Pid,Error} -> exit(Error) + end; + Pid -> + case get_mode() of + interactive when Mode==interactive -> + Pid; + interactive -> + {error,interactive_mode}; + _OtherMode -> + Pid + end + end. + +do_start(Parent,Mode,LogDir) -> + process_flag(trap_exit,true), + register(ct_util_server,self()), + create_table(?attr_table,bag,#ct_conf.key), + create_table(?conn_table,#conn.handle), + create_table(?board_table,2), + create_table(?suite_table,#suite_data.key), + {ok,StartDir} = file:get_cwd(), + case file:set_cwd(LogDir) of + ok -> ok; + E -> exit(E) + end, + Opts = case read_opts() of + {ok,Opts1} -> + Opts1; + Error -> + Parent ! {self(),Error}, + exit(Error) + end, + + %% start an event manager (if not already started by master) + case ct_event:start_link() of + {error,{already_started,_}} -> + ok; + _ -> + case whereis(vts) of + undefined -> + ct_event:add_handler(); + VtsPid -> + ct_event:add_handler([{vts,VtsPid}]) + end + end, + case read_config_files(Opts) of + ok -> + %% add user handlers + case lists:keysearch(event_handler,1,Opts) of + {value,{_,Handlers}} -> + Add = fun({H,Args}) -> + case catch gen_event:add_handler(?CT_EVMGR_REF,H,Args) of + ok -> ok; + {'EXIT',Why} -> exit(Why); + Other -> exit({event_handler,Other}) + end + end, + case catch lists:foreach(Add,Handlers) of + {'EXIT',Reason} -> + Parent ! {self(),Reason}; + _ -> + ok + end; + false -> + ok + end, + {StartTime,TestLogDir} = ct_logs:init(Mode), + ct_event:notify(#event{name=test_start, + node=node(), + data={StartTime, + lists:flatten(TestLogDir)}}), + Parent ! {self(),started}, + loop(Mode,[],StartDir); + ReadError -> + Parent ! {self(),ReadError}, + exit(ReadError) + end. + +create_table(TableName,KeyPos) -> + create_table(TableName,set,KeyPos). +create_table(TableName,Type,KeyPos) -> + catch ets:delete(TableName), + ets:new(TableName,[Type,named_table,public,{keypos,KeyPos}]). + +read_opts() -> + case file:consult(ct_run:variables_file_name("./")) of + {ok,Opts} -> + {ok,Opts}; + {error,enoent} -> + {error,not_installed}; + Error -> + {error,{bad_installation,Error}} + end. + +read_config_files(Opts) -> + ConfigFiles = + lists:foldl(fun({config,Files},Acc) -> + Acc ++ Files; + (_,Acc) -> + Acc + end,[],Opts), + read_config_files1(ConfigFiles). + +read_config_files1([ConfigFile|Files]) -> + case file:consult(ConfigFile) of + {ok,Config} -> + set_config(Config), + read_config_files1(Files); + {error,enoent} -> + {user_error,{config_file_error,ConfigFile,enoent}}; + {error,Reason} -> + Key = + case application:get_env(common_test, decrypt) of + {ok,KeyOrFile} -> + case KeyOrFile of + {key,K} -> + K; + {file,F} -> + get_crypt_key_from_file(F) + end; + _ -> + get_crypt_key_from_file() + end, + case Key of + {error,no_crypt_file} -> + {user_error,{config_file_error,ConfigFile,Reason}}; + {error,CryptError} -> + {user_error,{decrypt_file_error,ConfigFile,CryptError}}; + _ when is_list(Key) -> + case decrypt_config_file(ConfigFile, undefined, {key,Key}) of + {ok,CfgBin} -> + case read_config_terms(CfgBin) of + {error,ReadFail} -> + {user_error,{config_file_error,ConfigFile,ReadFail}}; + Config -> + set_config(Config), + read_config_files1(Files) + end; + {error,DecryptFail} -> + {user_error,{decrypt_config_error,ConfigFile,DecryptFail}} + end; + _ -> + {user_error,{bad_decrypt_key,ConfigFile,Key}} + end + end; +read_config_files1([]) -> + ok. + +read_config_terms(Bin) when is_binary(Bin) -> + case catch binary_to_list(Bin) of + {'EXIT',_} -> + {error,invalid_textfile}; + Lines -> + read_config_terms(Lines) + end; +read_config_terms(Lines) when is_list(Lines) -> + read_config_terms1(erl_scan:tokens([], Lines, 0), 1, [], []). + +read_config_terms1({done,{ok,Ts,EL},Rest}, L, Terms, _) -> + case erl_parse:parse_term(Ts) of + {ok,Term} when Rest == [] -> + lists:reverse([Term|Terms]); + {ok,Term} -> + read_config_terms1(erl_scan:tokens([], Rest, 0), + EL+1, [Term|Terms], Rest); + _ -> + {error,{bad_term,{L,EL}}} + end; +read_config_terms1({done,{eof,_},_}, _, Terms, Rest) when Rest == [] -> + lists:reverse(Terms); +read_config_terms1({done,{eof,EL},_}, L, _, _) -> + {error,{bad_term,{L,EL}}}; +read_config_terms1({done,{error,Info,EL},_}, L, _, _) -> + {error,{Info,{L,EL}}}; +read_config_terms1({more,_}, L, Terms, Rest) -> + case string:tokens(Rest, [$\n,$\r,$\t]) of + [] -> + lists:reverse(Terms); + _ -> + {error,{bad_term,L}} + end. + +set_default_config(NewConfig, Scope) -> + call({set_default_config, {NewConfig, Scope}}). + +set_default_config(Name, NewConfig, Scope) -> + call({set_default_config, {Name, NewConfig, Scope}}). + +delete_default_config(Scope) -> + call({delete_default_config, Scope}). + +update_config(Name, Config) -> + call({update_config, {Name, Config}}). + +save_suite_data(Key, Value) -> + call({save_suite_data, {Key, undefined, Value}}). + +save_suite_data(Key, Name, Value) -> + call({save_suite_data, {Key, Name, Value}}). + +read_suite_data(Key) -> + call({read_suite_data, Key}). + +delete_suite_data() -> + call({delete_suite_data, all}). + +delete_suite_data(Key) -> + call({delete_suite_data, Key}). + +match_delete_suite_data(KeyPat) -> + call({match_delete_suite_data, KeyPat}). + +delete_testdata() -> + call(delete_testdata). + +delete_testdata(Key) -> + call({delete_testdata, Key}). + +update_testdata(Key, Fun) -> + call({update_testdata, Key, Fun}). + +set_testdata(TestData) -> + call({set_testdata, TestData}). + +get_testdata(Key) -> + call({get_testdata, Key}). + +set_cwd(Dir) -> + call({set_cwd,Dir}). + +reset_cwd() -> + call(reset_cwd). + +loop(Mode,TestData,StartDir) -> + receive + {update_last_run_index,From} -> + ct_logs:make_last_run_index(), + return(From,ok), + loop(Mode,TestData,StartDir); + {{require,Name,Tag,SubTags},From} -> + Result = do_require(Name,Tag,SubTags), + return(From,Result), + loop(Mode,TestData,StartDir); + {{set_default_config,{Config,Scope}},From} -> + set_config(Config,{true,Scope}), + return(From,ok), + loop(Mode,TestData,StartDir); + {{set_default_config,{Name,Config,Scope}},From} -> + set_config(Name,Config,{true,Scope}), + return(From,ok), + loop(Mode,TestData,StartDir); + {{delete_default_config,Scope},From} -> + delete_config({true,Scope}), + return(From,ok), + loop(Mode,TestData,StartDir); + {{update_config,{Name,NewConfig}},From} -> + update_conf(Name,NewConfig), + return(From,ok), + loop(Mode,TestData,StartDir); + {{save_suite_data,{Key,Name,Value}},From} -> + ets:insert(?suite_table, #suite_data{key=Key, + name=Name, + value=Value}), + return(From,ok), + loop(Mode,TestData,StartDir); + {{read_suite_data,Key},From} -> + case ets:lookup(?suite_table, Key) of + [#suite_data{key=Key,name=undefined,value=Value}] -> + return(From,Value); + [#suite_data{key=Key,name=Name,value=Value}] -> + return(From,{Name,Value}); + _ -> + return(From,undefined) + end, + loop(Mode,TestData,StartDir); + {{delete_suite_data,Key},From} -> + if Key == all -> + ets:delete_all_objects(?suite_table); + true -> + ets:delete(?suite_table, Key) + end, + return(From,ok), + loop(Mode,TestData,StartDir); + {{match_delete_suite_data,KeyPat},From} -> + ets:match_delete(?suite_table, #suite_data{key=KeyPat, + name='_', + value='_'}), + return(From,ok), + loop(Mode,TestData,StartDir); + {delete_testdata,From} -> + return(From,ok), + loop(From,[],StartDir); + {{delete_testdata,Key},From} -> + TestData1 = lists:keydelete(Key,1,TestData), + return(From,ok), + loop(From,TestData1,StartDir); + {{set_testdata,New = {Key,_Val}},From} -> + TestData1 = lists:keydelete(Key,1,TestData), + return(From,ok), + loop(Mode,[New|TestData1],StartDir); + {{get_testdata,Key},From} -> + case lists:keysearch(Key,1,TestData) of + {value,{Key,Val}} -> + return(From,Val); + _ -> + return(From,undefined) + end, + loop(From,TestData,StartDir); + {{update_testdata,Key,Fun},From} -> + TestData1 = + case lists:keysearch(Key,1,TestData) of + {value,{Key,Val}} -> + NewVal = Fun(Val), + return(From,NewVal), + [{Key,NewVal}|lists:keydelete(Key,1,TestData)]; + _ -> + return(From,undefined), + TestData + end, + loop(From,TestData1,StartDir); + {{set_cwd,Dir},From} -> + return(From,file:set_cwd(Dir)), + loop(From,TestData,StartDir); + {reset_cwd,From} -> + return(From,file:set_cwd(StartDir)), + loop(From,TestData,StartDir); + {{stop,How},From} -> + Time = calendar:local_time(), + ct_event:sync_notify(#event{name=test_done, + node=node(), + data=Time}), + ets:delete(?attr_table), + close_connections(ets:tab2list(?conn_table)), + ets:delete(?conn_table), + ets:delete(?board_table), + ets:delete(?suite_table), + ct_logs:close(How), + file:set_cwd(StartDir), + ct_event:stop(), + return(From,ok); + {get_mode,From} -> + return(From,Mode), + loop(Mode,TestData,StartDir); + {'EXIT',_Pid,normal} -> + loop(Mode,TestData,StartDir); + {'EXIT',Pid,Reason} -> + %% Let process crash in case of error, this shouldn't happen! + io:format("\n\nct_util_server got EXIT from ~p: ~p\n\n", + [Pid,Reason]), + file:set_cwd(StartDir), + exit(Reason) + end. + + +close_connections([#conn{handle=Handle,callback=CB}|Conns]) -> + CB:close(Handle), + close_connections(Conns); +close_connections([]) -> + ok. + + +%%%----------------------------------------------------------------- +%%% @spec register_connection(TargetName,Address,Callback,Handle) -> +%%% ok | {error,Reason} +%%% TargetName = ct:target_name() +%%% Address = term() +%%% Callback = atom() +%%% Handle = term +%%% +%%% @doc Register a new connection (tool-internal use only). +%%% +%%% <p>This function can be called when a new connection is +%%% established. The connection data is stored in the connection +%%% table, and ct_util will close all registered connections when the +%%% test is finished by calling <code>Callback:close/1</code>.</p> +register_connection(TargetName,Address,Callback,Handle) -> + TargetRef = + case get_ref_from_name(TargetName) of + {ok,Ref} -> + Ref; + _ -> + %% no config name associated with connection, + %% use handle for identification instead + Handle + end, + ets:insert(?conn_table,#conn{handle=Handle, + targetref=TargetRef, + address=Address, + callback=Callback}), + ok. + +%%%----------------------------------------------------------------- +%%% @spec unregister_connection(Handle) -> ok +%%% Handle = term +%%% +%%% @doc Unregister a connection (tool-internal use only). +%%% +%%% <p>This function should be called when a registered connection is +%%% closed. It removes the connection data from the connection +%%% table.</p> +unregister_connection(Handle) -> + ets:delete(?conn_table,Handle), + ok. + + +%%%----------------------------------------------------------------- +%%% @spec does_connection_exist(TargetName,Address,Callback) -> +%%% {ok,Handle} | false +%%% TargetName = ct:target_name() +%%% Address = address +%%% Callback = atom() +%%% Handle = term() +%%% +%%% @doc Check if a connection already exists. +does_connection_exist(TargetName,Address,Callback) -> + case get_ref_from_name(TargetName) of + {ok,TargetRef} -> + case ets:select(?conn_table,[{#conn{handle='$1', + targetref=TargetRef, + address=Address, + callback=Callback}, + [], + ['$1']}]) of + [Handle] -> + {ok,Handle}; + [] -> + false + end; + _ -> + false + end. + +%%%----------------------------------------------------------------- +%%% @spec get_connections(TargetName,Callback) -> +%%% {ok,Connections} | {error,Reason} +%%% TargetName = ct:target_name() +%%% Callback = atom() +%%% Connections = [Connection] +%%% Connection = {Handle,Address} +%%% Handle = term() +%%% Address = term() +%%% +%%% @doc Return all connections for the <code>Callback</code> on the +%%% given target (<code>TargetName</code>). +get_connections(TargetName,Callback) -> + case get_ref_from_name(TargetName) of + {ok,Ref} -> + {ok,ets:select(?conn_table,[{#conn{handle='$1', + address='$2', + targetref=Ref, + callback=Callback}, + [], + [{{'$1','$2'}}]}])}; + Error -> + Error + end. + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:get_target_name/1 +get_target_name(ConnPid) -> + case ets:select(?conn_table,[{#conn{handle=ConnPid,targetref='$1',_='_'}, + [], + ['$1']}]) of + [TargetRef] -> + get_name_from_ref(TargetRef); + [] -> + {error,{unknown_connection,ConnPid}} + end. + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:require/1 +require(Key) when is_atom(Key) -> + require({Key,[]}); +require({Key,SubKeys}) when is_atom(Key) -> + allocate('_UNDEF',Key,to_list(SubKeys)); +require(Key) -> + {error,{invalid,Key}}. + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:require/2 +require(Name,Key) when is_atom(Key) -> + require(Name,{Key,[]}); +require(Name,{Key,SubKeys}) when is_atom(Name), is_atom(Key) -> + call({require,Name,Key,to_list(SubKeys)}); +require(Name,Keys) -> + {error,{invalid,{Name,Keys}}}. + +to_list(X) when is_list(X) -> X; +to_list(X) -> [X]. + +do_require(Name,Key,SubKeys) when is_list(SubKeys) -> + case get_key_from_name(Name) of + {error,_} -> + allocate(Name,Key,SubKeys); + {ok,Key} -> + %% already allocated - check that it has all required subkeys + Vals = [Val || {_Ref,Val} <- lookup_name(Name)], + case get_subconfig(SubKeys,Vals) of + {ok,_SubMapped} -> + ok; + Error -> + Error + end; + {ok,OtherKey} -> + {error,{name_in_use,Name,OtherKey}} + end. + +allocate(Name,Key,SubKeys) -> + case ets:match_object(?attr_table,#ct_conf{key=Key,name='_UNDEF',_='_'}) of + [] -> + {error,{not_available,Key}}; + Available -> + case allocate_subconfig(Name,SubKeys,Available,false) of + ok -> + ok; + Error -> + Error + end + end. + +allocate_subconfig(Name,SubKeys,[C=#ct_conf{value=Value}|Rest],Found) -> + case do_get_config(SubKeys,Value,[]) of + {ok,_SubMapped} -> + ets:insert(?attr_table,C#ct_conf{name=Name}), + allocate_subconfig(Name,SubKeys,Rest,true); + _Error -> + allocate_subconfig(Name,SubKeys,Rest,Found) + end; +allocate_subconfig(_Name,_SubKeys,[],true) -> + ok; +allocate_subconfig(_Name,SubKeys,[],false) -> + {error,{not_available,SubKeys}}. + + + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:get_config/1 +get_config(KeyOrName) -> + get_config(KeyOrName,undefined,[]). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:get_config/2 +get_config(KeyOrName,Default) -> + get_config(KeyOrName,Default,[]). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:get_config/3 +get_config(KeyOrName,Default,Opts) when is_atom(KeyOrName) -> + case lookup_config(KeyOrName) of + [] -> + Default; + [{_Ref,Val}|_] = Vals -> + case {lists:member(all,Opts),lists:member(element,Opts)} of + {true,true} -> + [{KeyOrName,V} || {_R,V} <- lists:sort(Vals)]; + {true,false} -> + [V || {_R,V} <- lists:sort(Vals)]; + {false,true} -> + {KeyOrName,Val}; + {false,false} -> + Val + end + end; + +get_config({KeyOrName,SubKey},Default,Opts) -> + case lookup_config(KeyOrName) of + [] -> + Default; + Vals -> + Vals1 = case [Val || {_Ref,Val} <- lists:sort(Vals)] of + Result=[L|_] when is_list(L) -> + case L of + [{_,_}|_] -> + Result; + _ -> + [] + end; + _ -> + [] + end, + case get_subconfig([SubKey],Vals1,[],Opts) of + {ok,[{_,SubVal}|_]=SubVals} -> + case {lists:member(all,Opts),lists:member(element,Opts)} of + {true,true} -> + [{{KeyOrName,SubKey},Val} || {_,Val} <- SubVals]; + {true,false} -> + [Val || {_SubKey,Val} <- SubVals]; + {false,true} -> + {{KeyOrName,SubKey},SubVal}; + {false,false} -> + SubVal + end; + _ -> + Default + end + end. + + +get_subconfig(SubKeys,Values) -> + get_subconfig(SubKeys,Values,[],[]). + +get_subconfig(SubKeys,[Value|Rest],Mapped,Opts) -> + case do_get_config(SubKeys,Value,[]) of + {ok,SubMapped} -> + case lists:member(all,Opts) of + true -> + get_subconfig(SubKeys,Rest,Mapped++SubMapped,Opts); + false -> + {ok,SubMapped} + end; + _Error -> + get_subconfig(SubKeys,Rest,Mapped,Opts) + end; +get_subconfig(SubKeys,[],[],_) -> + {error,{not_available,SubKeys}}; +get_subconfig(_SubKeys,[],Mapped,_) -> + {ok,Mapped}. + +do_get_config([Key|Required],Available,Mapped) -> + case lists:keysearch(Key,1,Available) of + {value,{Key,Value}} -> + NewAvailable = lists:keydelete(Key,1,Available), + NewMapped = [{Key,Value}|Mapped], + do_get_config(Required,NewAvailable,NewMapped); + false -> + {error,{not_available,Key}} + end; +do_get_config([],_Available,Mapped) -> + {ok,lists:reverse(Mapped)}. + +get_all_config() -> + ets:select(?attr_table,[{#ct_conf{name='$1',key='$2',value='$3', + default='$4',_='_'}, + [], + [{{'$1','$2','$3','$4'}}]}]). + +lookup_config(KeyOrName) -> + case lookup_name(KeyOrName) of + [] -> + lookup_key(KeyOrName); + Values -> + Values + end. + +lookup_name(Name) -> + ets:select(?attr_table,[{#ct_conf{ref='$1',value='$2',name=Name,_='_'}, + [], + [{{'$1','$2'}}]}]). +lookup_key(Key) -> + ets:select(?attr_table,[{#ct_conf{key=Key,ref='$1',value='$2',name='_UNDEF',_='_'}, + [], + [{{'$1','$2'}}]}]). + +set_config(Config) -> + set_config('_UNDEF',Config,false). + +set_config(Config,Default) -> + set_config('_UNDEF',Config,Default). + +set_config(Name,Config,Default) -> + [ets:insert(?attr_table, + #ct_conf{key=Key,value=Val,ref=ct_make_ref(), + name=Name,default=Default}) || + {Key,Val} <- Config]. + +delete_config(Default) -> + ets:match_delete(?attr_table,#ct_conf{default=Default,_='_'}), + ok. + + +%%%----------------------------------------------------------------- +%%% @spec release_allocated() -> ok +%%% +%%% @doc Release all allocated resources, but don't take down any +%%% connections. +release_allocated() -> + Allocated = ets:select(?attr_table,[{#ct_conf{name='$1',_='_'}, + [{'=/=','$1','_UNDEF'}], + ['$_']}]), + release_allocated(Allocated). +release_allocated([H|T]) -> + ets:delete_object(?attr_table,H), + ets:insert(?attr_table,H#ct_conf{name='_UNDEF'}), + release_allocated(T); +release_allocated([]) -> + ok. + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +update_conf(Name, NewConfig) -> + Old = ets:select(?attr_table,[{#ct_conf{name=Name,_='_'},[],['$_']}]), + lists:foreach(fun(OldElem) -> + NewElem = OldElem#ct_conf{value=NewConfig}, + ets:delete_object(?attr_table, OldElem), + ets:insert(?attr_table, NewElem) + end, Old), + ok. + +%%%----------------------------------------------------------------- +%%% @spec close_connections() -> ok +%%% +%%% @doc Close all open connections. +close_connections() -> + close_connections(ets:tab2list(?conn_table)), + ok. + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +override_silence_all_connections() -> + Protocols = [telnet,ftp,rpc,snmp], + override_silence_connections(Protocols), + Protocols. + +override_silence_connections(Conns) when is_list(Conns) -> + Conns1 = lists:map(fun({C,B}) -> {C,B}; + (C) -> {C,true} + end, Conns), + set_testdata({override_silent_connections,Conns1}). + +get_overridden_silenced_connections() -> + case get_testdata(override_silent_connections) of + {error,_} -> + undefined; + Conns -> % list() or undefined + Conns + end. + +delete_overridden_silenced_connections() -> + delete_testdata(override_silent_connections). + +silence_all_connections() -> + Protocols = [telnet,ftp,rpc,snmp], + silence_connections(Protocols), + Protocols. + +silence_connections(Conn) when is_tuple(Conn) -> + silence_connections([Conn]); +silence_connections(Conn) when is_atom(Conn) -> + silence_connections([{Conn,true}]); +silence_connections(Conns) when is_list(Conns) -> + Conns1 = lists:map(fun({C,B}) -> {C,B}; + (C) -> {C,true} + end, Conns), + set_testdata({silent_connections,Conns1}). + +is_silenced(Conn) -> + case get_testdata(silent_connections) of + Conns when is_list(Conns) -> + case lists:keysearch(Conn,1,Conns) of + {value,{Conn,true}} -> + true; + _ -> + false + end; + _ -> + false + end. + +reset_silent_connections() -> + delete_testdata(silent_connections). + + +%%%----------------------------------------------------------------- +%%% @spec stop(How) -> ok +%%% +%%% @doc Stop the ct_util_server and close all existing connections +%%% (tool-internal use only). +%%% +%%% @see ct +stop(How) -> + case whereis(ct_util_server) of + undefined -> ok; + _ -> call({stop,How}) + end. + +%%%----------------------------------------------------------------- +%%% @spec update_last_run_index() -> ok +%%% +%%% @doc Update <code>ct_run.<timestamp>/index.html</code> +%%% (tool-internal use only). +update_last_run_index() -> + call(update_last_run_index). + + +%%%----------------------------------------------------------------- +%%% @spec get_mode() -> Mode +%%% Mode = normal | interactive +%%% +%%% @doc Return the current mode of the ct_util_server +%%% (tool-internal use only). +get_mode() -> + call(get_mode). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:listenv/1 +listenv(Telnet) -> + case ct_telnet:send(Telnet,"listenv") of + ok -> + {ok,Data,_} = ct_telnet:expect(Telnet, + ["(^.+)=(.*$)"], + [{timeout,seconds(3)}, + repeat]), + {ok,[{Name,Val} || [_,Name,Val] <- Data]}; + {error,Reason} -> + {error,{could_not_send_command,Telnet,"listenv",Reason}} + end. + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @equiv ct:parse_table/1 +parse_table(Data) -> + [Heading|Lines]= + [remove_space(string:tokens(L, "|"),[]) || L <- Data, hd(L)==$|], + {Heading,Lines}. + +remove_space([Str|Rest],Acc) -> + remove_space(Rest,[string:strip(string:strip(Str),both,$')|Acc]); +remove_space([],Acc) -> + list_to_tuple(lists:reverse(Acc)). + + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +is_test_dir(Dir) -> + lists:last(string:tokens(filename:basename(Dir), "_")) == "test". + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +get_testdir(Dir, all) -> + Abs = abs_name(Dir), + case is_test_dir(Abs) of + true -> + Abs; + false -> + AbsTest = filename:join(Abs, "test"), + case filelib:is_dir(AbsTest) of + true -> AbsTest; + false -> Abs + end + end; + +get_testdir(Dir, [Suite | _]) when is_atom(Suite) -> + get_testdir(Dir, atom_to_list(Suite)); + +get_testdir(Dir, [Suite | _]) when is_list(Suite) -> + get_testdir(Dir, Suite); + +get_testdir(Dir, Suite) when is_atom(Suite) -> + get_testdir(Dir, atom_to_list(Suite)); + +get_testdir(Dir, Suite) when is_list(Suite) -> + Abs = abs_name(Dir), + case is_test_dir(Abs) of + true -> + Abs; + false -> + AbsTest = filename:join(Abs, "test"), + Mod = case filename:extension(Suite) of + ".erl" -> Suite; + _ -> Suite ++ ".erl" + end, + case filelib:is_file(filename:join(AbsTest, Mod)) of + true -> AbsTest; + false -> Abs + end + end; + +get_testdir(Dir, _) -> + get_testdir(Dir, all). + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +encrypt_config_file(SrcFileName, EncryptFileName) -> + case get_crypt_key_from_file() of + {error,_} = E -> + E; + Key -> + encrypt_config_file(SrcFileName, EncryptFileName, {key,Key}) + end. + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +encrypt_config_file(SrcFileName, EncryptFileName, {file,KeyFile}) -> + case get_crypt_key_from_file(KeyFile) of + {error,_} = E -> + E; + Key -> + encrypt_config_file(SrcFileName, EncryptFileName, {key,Key}) + end; + +encrypt_config_file(SrcFileName, EncryptFileName, {key,Key}) -> + crypto:start(), + {K1,K2,K3,IVec} = make_crypto_key(Key), + case file:read_file(SrcFileName) of + {ok,Bin0} -> + Bin1 = term_to_binary({SrcFileName,Bin0}), + Bin2 = case byte_size(Bin1) rem 8 of + 0 -> Bin1; + N -> list_to_binary([Bin1,random_bytes(8-N)]) + end, + EncBin = crypto:des3_cbc_encrypt(K1, K2, K3, IVec, Bin2), + case file:write_file(EncryptFileName, EncBin) of + ok -> + io:format("~s --(encrypt)--> ~s~n", + [SrcFileName,EncryptFileName]), + ok; + {error,Reason} -> + {error,{Reason,EncryptFileName}} + end; + {error,Reason} -> + {error,{Reason,SrcFileName}} + end. + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +decrypt_config_file(EncryptFileName, TargetFileName) -> + case get_crypt_key_from_file() of + {error,_} = E -> + E; + Key -> + decrypt_config_file(EncryptFileName, TargetFileName, {key,Key}) + end. + + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +decrypt_config_file(EncryptFileName, TargetFileName, {file,KeyFile}) -> + case get_crypt_key_from_file(KeyFile) of + {error,_} = E -> + E; + Key -> + decrypt_config_file(EncryptFileName, TargetFileName, {key,Key}) + end; + +decrypt_config_file(EncryptFileName, TargetFileName, {key,Key}) -> + crypto:start(), + {K1,K2,K3,IVec} = make_crypto_key(Key), + case file:read_file(EncryptFileName) of + {ok,Bin} -> + DecBin = crypto:des3_cbc_decrypt(K1, K2, K3, IVec, Bin), + case catch binary_to_term(DecBin) of + {'EXIT',_} -> + {error,bad_file}; + {_SrcFile,SrcBin} -> + case TargetFileName of + undefined -> + {ok,SrcBin}; + _ -> + case file:write_file(TargetFileName, SrcBin) of + ok -> + io:format("~s --(decrypt)--> ~s~n", + [EncryptFileName,TargetFileName]), + ok; + {error,Reason} -> + {error,{Reason,TargetFileName}} + end + end + end; + {error,Reason} -> + {error,{Reason,EncryptFileName}} + end. + + +get_crypt_key_from_file(File) -> + case file:read_file(File) of + {ok,Bin} -> + case catch string:tokens(binary_to_list(Bin), [$\n,$\r]) of + [Key] -> + Key; + _ -> + {error,{bad_crypt_file,File}} + end; + {error,Reason} -> + {error,{Reason,File}} + end. + +get_crypt_key_from_file() -> + CwdFile = filename:join(".",?cryptfile), + {Result,FullName} = + case file:read_file(CwdFile) of + {ok,Bin} -> + {Bin,CwdFile}; + _ -> + case init:get_argument(home) of + {ok,[[Home]]} -> + HomeFile = filename:join(Home,?cryptfile), + case file:read_file(HomeFile) of + {ok,Bin} -> + {Bin,HomeFile}; + _ -> + {{error,no_crypt_file},noent} + end; + _ -> + {{error,no_crypt_file},noent} + end + end, + case FullName of + noent -> + Result; + _ -> + case catch string:tokens(binary_to_list(Result), [$\n,$\r]) of + [Key] -> + io:format("~nCrypt key file: ~s~n", [FullName]), + Key; + _ -> + {error,{bad_crypt_file,FullName}} + end + end. + +make_crypto_key(String) -> + <<K1:8/binary,K2:8/binary>> = First = erlang:md5(String), + <<K3:8/binary,IVec:8/binary>> = erlang:md5([First|lists:reverse(String)]), + {K1,K2,K3,IVec}. + +random_bytes(N) -> + {A,B,C} = now(), + random:seed(A, B, C), + random_bytes_1(N, []). + +random_bytes_1(0, Acc) -> Acc; +random_bytes_1(N, Acc) -> random_bytes_1(N-1, [random:uniform(255)|Acc]). + + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +get_attached(TCPid) -> + case dbg_iserver:safe_call({get_attpid,TCPid}) of + {ok,AttPid} when is_pid(AttPid) -> + AttPid; + _ -> + undefined + end. + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +kill_attached(undefined,_AttPid) -> + ok; +kill_attached(_TCPid,undefined) -> + ok; +kill_attached(TCPid,AttPid) -> + case process_info(TCPid) of + undefined -> + exit(AttPid,kill); + _ -> + ok + end. + + +%%%----------------------------------------------------------------- +%%% @spec +%%% +%%% @doc +warn_duplicates(Suites) -> + Warn = + fun(Mod) -> + case catch apply(Mod,sequences,[]) of + {'EXIT',_} -> + ok; + [] -> + ok; + _ -> + io:format(user,"~nWARNING! Deprecated function: ~w:sequences/0.~n" + " Use group with sequence property instead.~n",[Mod]) + end + end, + lists:foreach(Warn, Suites), + ok. + + +%%%----------------------------------------------------------------- +%%% Internal functions +call(Msg) -> + MRef = erlang:monitor(process,whereis(ct_util_server)), + Ref = make_ref(), + ct_util_server ! {Msg,{self(),Ref}}, + receive + {Ref, Result} -> + erlang:demonitor(MRef), + Result; + {'DOWN',MRef,process,_,Reason} -> + {error,{ct_util_server_down,Reason}} + end. + +return({To,Ref},Result) -> + To ! {Ref, Result}. + +seconds(T) -> + test_server:seconds(T). + +ct_make_ref() -> + Pid = case whereis(ct_make_ref) of + undefined -> + spawn_link(fun() -> ct_make_ref_init() end); + P -> + P + end, + Pid ! {self(),ref_req}, + receive + {Pid,Ref} -> Ref + end. + +ct_make_ref_init() -> + register(ct_make_ref,self()), + ct_make_ref_loop(0). + +ct_make_ref_loop(N) -> + receive + {From,ref_req} -> + From ! {self(),N}, + ct_make_ref_loop(N+1) + end. + +get_ref_from_name(Name) -> + case ets:select(?attr_table,[{#ct_conf{name=Name,ref='$1',_='_'}, + [], + ['$1']}]) of + [Ref] -> + {ok,Ref}; + _ -> + {error,{no_such_name,Name}} + end. + +get_name_from_ref(Ref) -> + case ets:select(?attr_table,[{#ct_conf{name='$1',ref=Ref,_='_'}, + [], + ['$1']}]) of + [Name] -> + {ok,Name}; + _ -> + {error,{no_such_ref,Ref}} + end. + +get_key_from_name(Name) -> + case ets:select(?attr_table,[{#ct_conf{name=Name,key='$1',_='_'}, + [], + ['$1']}]) of + [Key|_] -> + {ok,Key}; + _ -> + {error,{no_such_name,Name}} + end. + + +abs_name(Dir0) -> + Abs = filename:absname(Dir0), + Dir = case lists:reverse(Abs) of + [$/|Rest] -> lists:reverse(Rest); + _ -> Abs + end, + abs_name1(Dir,[]). + +abs_name1([Drv,$:,$/],Acc) -> + Split = [[Drv,$:,$/]|Acc], + abs_name2(Split,[]); +abs_name1("/",Acc) -> + Split = ["/"|Acc], + abs_name2(Split,[]); +abs_name1(Dir,Acc) -> + abs_name1(filename:dirname(Dir),[filename:basename(Dir)|Acc]). + +abs_name2([".."|T],[_|Acc]) -> + abs_name2(T,Acc); +abs_name2(["."|T],Acc) -> + abs_name2(T,Acc); +abs_name2([H|T],Acc) -> + abs_name2(T,[H|Acc]); +abs_name2([],Acc) -> + filename:join(lists:reverse(Acc)). diff --git a/lib/common_test/src/ct_util.hrl b/lib/common_test/src/ct_util.hrl new file mode 100644 index 0000000000..94ae2625cf --- /dev/null +++ b/lib/common_test/src/ct_util.hrl @@ -0,0 +1,51 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +-define(attr_table,ct_attributes). +-define(conn_table,ct_connections). +-define(board_table,ct_boards). +-define(suite_table,ct_suite_data). + +-record(conn, {handle, + targetref, + address, + callback}). + +-record(testspec, {nodes=[], + logdir=["."], + cover=[], + config=[], + event_handler=[], + include=[], + alias=[], + tests=[]}). + +-record(cover, {app=none, + level=details, + excl_mods=[], + incl_mods=[], + cross=[], + src=[]}). + +-define(CT_EVMGR, ct_event). +-define(CT_EVMGR_REF, ct_event). +-define(CT_MEVMGR, ct_master_event). +-define(CT_MEVMGR_REF, ct_master_event). + +-define(missing_suites_info, "missing_suites.info"). diff --git a/lib/common_test/src/unix_telnet.erl b/lib/common_test/src/unix_telnet.erl new file mode 100644 index 0000000000..14a70e9d22 --- /dev/null +++ b/lib/common_test/src/unix_telnet.erl @@ -0,0 +1,152 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%% @doc Callback module for ct_telnet for talking telnet +%%% to a unix host. +%%% +%%% <p>It requires the following entry in the config file:</p> +%%% <pre> +%%% {unix,[{telnet,HostNameOrIpAddress}, +%%% {port,PortNum}, +%%% {username,UserName}, +%%% {password,Password}]}. +%%% </pre> +%%% +%%% <p>To talk telnet to the host specified by +%%% <code>HostNameOrIpAddress</code>, use the interface functions in +%%% <code>ct</code>, e.g. <code>open(Name), cmd(Name,Cmd), ...</code>.</p> +%%% +%%% <p><code>Name</code> is the name you allocated to the unix host in +%%% your <code>require</code> statement. E.g.</p> +%%% <pre> suite() -> [{require,Name,{unix,[telnet,username,password]}}].</pre> +%%% <p>or</p> +%%% <pre> ct:require(Name,{unix,[telnet,username,password]}).</pre> +%%% +%%% <p>Note that the <code>{port,PortNum}</code> tuple is optional and if +%%% omitted, default telnet port 23 will be used.</p> +%%% +%%% @see ct +%%% @see ct_telnet +-module(unix_telnet). + +-compile(export_all). + +%% Callbacks for ct_telnet.erl +-export([connect/4,get_prompt_regexp/0]). +-import(ct_telnet,[start_log/1,cont_log/2,end_log/0]). + +-define(username,"login: "). +-define(password,"Password: "). +-define(prx,"login: |Password: |\\\$ |> "). + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @spec get_prompt_regexp() -> PromptRegexp +%%% PromptRegexp = ct_telnet:prompt_regexp() +%%% +%%% @doc Callback for ct_telnet.erl. +%%% +%%% <p>Return the prompt regexp for telnet connections to the +%%% interwatch instrument.</p> +get_prompt_regexp() -> + ?prx. + + +%%%----------------------------------------------------------------- +%%% @hidden +%%% @spec connect(Ip,Port,Timeout,Extra) -> {ok,Handle} | {error,Reason} +%%% Ip = string() | {integer(),integer(),integer(),integer()} +%%% Port = integer() +%%% Timeout = integer() +%%% Extra = {Username,Password} +%%% Username = string() +%%% Password = string() +%%% Handle = ct_telnet:handle() +%%% +%%% @doc Callback for ct_telnet.erl. +%%% +%%% <p>Setup telnet connection to a UNIX host.</p> +connect(Ip,Port,Timeout,Extra) -> + case Extra of + {Username,Password} -> + connect(Ip,Port,Timeout,Username,Password); + Name -> + case get_username_and_password(Name) of + {ok,{Username,Password}} -> + connect(Ip,Port,Timeout,Username,Password); + Error -> + Error + end + end. + +connect(Ip,Port,Timeout,Username,Password) -> + start_log("unix_telnet:connect"), + Result = + case ct_telnet_client:open(Ip,Port,Timeout) of + {ok,Pid} -> + case ct_telnet:silent_teln_expect(Pid,[],[prompt],?prx,[]) of + {ok,{prompt,?username},_} -> + ok = ct_telnet_client:send_data(Pid,Username), + cont_log("Username: ~s",[Username]), + case ct_telnet:silent_teln_expect(Pid,[],prompt,?prx,[]) of + {ok,{prompt,?password},_} -> + ok = ct_telnet_client:send_data(Pid,Password), + Stars = lists:duplicate(length(Password),$*), + cont_log("Password: ~s",[Stars]), + ok = ct_telnet_client:send_data(Pid,""), + case ct_telnet:silent_teln_expect(Pid,[],prompt, + ?prx,[]) of + {ok,{prompt,Prompt},_} + when Prompt=/=?username, Prompt=/=?password -> + {ok,Pid}; + Error -> + cont_log("Password failed\n~p\n", + [Error]), + {error,Error} + end; + Error -> + cont_log("Login failed\n~p\n",[Error]), + {error,Error} + end; + {ok,[{prompt,_OtherPrompt1},{prompt,_OtherPrompt2}],_} -> + {ok,Pid}; + Error -> + cont_log("Did not get expected prompt\n~p\n",[Error]), + {error,Error} + end; + Error -> + cont_log("Could not open telnet connection\n~p\n",[Error]), + Error + end, + end_log(), + Result. + +get_username_and_password(Name) -> + case ct:get_config({Name,username}) of + undefined -> + {error,{no_username,Name}}; + Username -> + case ct:get_config({Name,password}) of + undefined -> + {error,{no_password,Name}}; + Password -> + {ok,{Username,Password}} + end + end. + diff --git a/lib/common_test/src/vts.erl b/lib/common_test/src/vts.erl new file mode 100644 index 0000000000..ad4845a7c3 --- /dev/null +++ b/lib/common_test/src/vts.erl @@ -0,0 +1,882 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2003-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +-module(vts). + +-export([start/0, + init_data/4, + stop/0, + report/2]). + +-export([config_data/0, + start_link/0]). + +-export([start_page/2, + title_frame/2, + menu_frame/2, + welcome_frame/2, + config_frame/2, + add_config_file/2, + remove_config_file/2, + run_frame/2, + add_test_dir/2, + remove_test_dir/2, + select_case/2, + select_suite/2, + run_test/2, + result_frameset/2, + result_summary_frame/2, + no_result_log_frame/2, + redirect_to_result_log_frame/2]). + +-export([test_info/3]). + +-define(START_PAGE,"/vts_erl/vts/start_page"). + +-define(tests,vts_tests). + +%% Colors +-define(INFO_BG_COLOR,"#C0C0EA"). + +-record(state,{tests=[],config=[],event_handler=[],test_runner, + running=0,reload_results=false,start_dir,current_log_dir, + total=0,ok=0,fail=0,skip=0,testruns=[]}). + + +%%%----------------------------------------------------------------- +%%% User API +start() -> + webtool:start(), + webtool:start_tools([],"app=vts"). + +init_data(ConfigFiles,EvHandlers,LogDir,Tests) -> + call({init_data,ConfigFiles,EvHandlers,LogDir,Tests}). + +stop() -> + webtool:stop_tools([],"app=vts"), + webtool:stop(). + +report(What,Data) -> + call({report,What,Data}). + +%%%----------------------------------------------------------------- +%%% Return config data used by webtool +config_data() -> + {ok,LogDir} = + case lists:keysearch(logdir,1,init:get_arguments()) of + {value,{logdir,[LogD]}} -> {ok,filename:absname(LogD)}; + false -> file:get_cwd() + end, + {vts, + [{web_data,{"VisualTestServer",?START_PAGE}}, + {alias,{erl_alias,"/vts_erl",[?MODULE]}}, + {alias,{"/log_dir",LogDir}}, + {start,{child,{{local,?MODULE}, + {?MODULE,start_link,[]}, + permanent,100,worker,[?MODULE]}}} + ]}. + +start_link() -> + case whereis(?MODULE) of + undefined -> + Self = self(), + Pid = spawn_link(fun() -> init(Self) end), + MRef = erlang:monitor(process,Pid), + receive + {Pid,started} -> + erlang:demonitor(MRef), + {ok,Pid}; + {'DOWN',MRef,process,_,Reason} -> + {error,{vts,died,Reason}} + end; + Pid -> + {ok,Pid} + end. + +start_page(_Env,_Input) -> + call(start_page). +title_frame(_Env,_Input) -> + call(title_frame). +welcome_frame(_Env,_Input) -> + call(welcome_frame). +menu_frame(_Env,_Input) -> + call(menu_frame). +config_frame(_Env,_Input) -> + call(config_frame). +add_config_file(_Env,Input) -> + call({add_config_file,Input}). +remove_config_file(_Env,Input) -> + call({remove_config_file,Input}). +run_frame(_Env,_Input) -> + call(run_frame). +add_test_dir(_Env,Input) -> + call({add_test_dir,Input}). +remove_test_dir(_Env,Input) -> + call({remove_test_dir,Input}). +select_suite(_Env,Input) -> + call({select_suite,Input}). +select_case(_Env,Input) -> + call({select_case,Input}). +run_test(_Env,_Input) -> + call(run_test). +result_frameset(_Env,_Input) -> + call(result_frameset). +redirect_to_result_log_frame(_Env,_Input) -> + call(redirect_to_result_log_frame). +result_summary_frame(_Env,_Input) -> + call(result_summary_frame). +no_result_log_frame(_Env,_Input) -> + call(no_result_log_frame). + +aborted() -> + call(aborted). + +test_info(_VtsPid,Type,Data) -> + call({test_info,Type,Data}). + +init(Parent) -> + register(?MODULE,self()), + process_flag(trap_exit,true), + Parent ! {self(),started}, + {ok,Cwd} = file:get_cwd(), + InitState = #state{start_dir=Cwd}, + loop(InitState). + +loop(State) -> + receive + {{init_data,ConfigFiles,EvHandlers,LogDir,Tests},From} -> + ct_install(State), + return(From,ok), + loop(#state{config=ConfigFiles,event_handler=EvHandlers, + current_log_dir=LogDir,tests=Tests}); + {start_page,From} -> + return(From,start_page1()), + loop(State); + {title_frame,From} -> + return(From,title_frame1()), + loop(State); + {welcome_frame,From} -> + return(From,welcome_frame1()), + loop(State); + {menu_frame,From} -> + return(From,menu_frame1()), + loop(State); + {config_frame,From} -> + return(From,config_frame1(State)), + loop(State); + {{add_config_file,Input},From} -> + {Return,State1} = add_config_file1(Input,State), + ct_install(State1), + return(From,Return), + loop(State1); + {{remove_config_file,Input},From} -> + {Return,State1} = remove_config_file1(Input,State), + ct_install(State1), + return(From,Return), + loop(State1); + {run_frame,From} -> + return(From,run_frame1(State)), + loop(State); + {{add_test_dir,Input},From} -> + {Return,State1} = add_test_dir1(Input,State), + return(From,Return), + loop(State1); + {{remove_test_dir,Input},From} -> + {Return,State1} = remove_test_dir1(Input,State), + return(From,Return), + loop(State1); + {{select_suite,Input},From} -> + {Return,State1} = select_suite1(Input,State), + return(From,Return), + loop(State1); + {{select_case,Input},From} -> + {Return,State1} = select_case1(Input,State), + return(From,Return), + loop(State1); + {run_test,From} -> + State1 = run_test1(State), + return(From,redirect_to_result_frameset1()), + loop(State1); + {result_frameset,From} -> + return(From,result_frameset1(State)), + loop(State); + {redirect_to_result_log_frame,From} -> + return(From,redirect_to_result_log_frame1(State)), + loop(State); + {result_summary_frame,From} -> + return(From,result_summary_frame1(State)), + loop(State); + stop_reload_results -> + file:set_cwd(State#state.start_dir), + loop(State#state{reload_results=false}); + {no_result_log_frame,From} -> + return(From,no_result_log_frame1()), + loop(State); + {aborted,From} -> + return(From,ok), + loop(State#state{test_runner=undefined,running=0}); + {{report,What,Data},From} -> + State1 = report1(What,Data,State), + return(From,ok), + loop(State1); + {stop,From} -> + return(From,ok); + {'EXIT',Pid,Reason} -> + case State#state.test_runner of + Pid -> io:format("ERROR: test runner crashed: ~p\n",[Reason]); + _ -> ignore + end, + loop(State); + {{test_info,_Type,_Data},From} -> + return(From,ok), + loop(State) + end. + +call(Msg) -> + case whereis(?MODULE) of + undefined -> {error,no_proc}; + Pid -> + MRef = erlang:monitor(process,Pid), + Ref = make_ref(), + Pid ! {Msg,{self(),Ref}}, + receive + {Ref, Result} -> + erlang:demonitor(MRef), + Result; + {'DOWN',MRef,process,_,Reason} -> + {error,{process_down,Pid,Reason}} + end + end. + +return({To,Ref},Result) -> + To ! {Ref, Result}. + + +run_test1(State=#state{tests=Tests,current_log_dir=LogDir}) -> + Self=self(), + RunTest = fun() -> + case ct_run:do_run(Tests,[],LogDir) of + {error,_Reason} -> + aborted(); + _ -> + ok + end, + unlink(Self) + end, + + Pid = spawn_link(RunTest), + + Total = + receive + {{test_info,start_info,{_,_,Cases}},From} -> + return(From,ok), + Cases; + EXIT = {'EXIT',_,_} -> + self() ! EXIT + after 30000 -> + 0 + end, + State#state{test_runner=Pid,running=length(Tests), + total=Total,ok=0,fail=0,skip=0,testruns=[]}. + + +ct_install(#state{config=Config,event_handler=EvHandlers, + current_log_dir=LogDir}) -> + ct_run:install([{config,Config},{event_handler,EvHandlers}],LogDir). + +%%%----------------------------------------------------------------- +%%% HTML +start_page1() -> + header("Visual Test Server Start Page",start_page_frameset()). + +start_page_frameset() -> + frameset( + "ROWS=\"60,*\"", + [frame(["NAME=\"title\" SRC=\"./title_frame\""]), + frameset( + "COLS=\"150,*\"", + [frame(["NAME=\"menu\" SRC=\"./menu_frame\""]), + frame(["NAME=\"main\" SRC=\"./welcome_frame\""])])]). + + +title_frame1() -> + header(body("BGCOLOR=lightgrey TEXT=darkgreen",title_body())). + +title_body() -> + p("ALIGN=center",font("SIZE=\"+3\"",b("Visual Test Server"))). + +welcome_frame1() -> + header(body(welcome_body())). + +welcome_body() -> + table( + "WIDTH=100% HEIGHT=60%", + [tr("VALIGN=middle", + td("ALIGN=center", + font("SIZE=6", + ["Welcome to the",br(), + "Visual Test Server"])))]). + +menu_frame1() -> + header(body(menu_body())). + +menu_body() -> + [h2("Content"), + ul([ + li(href(["TARGET=\"main\""],"./config_frame","Config")), + li(href(["TARGET=\"main\""],"./run_frame","Run")), + li(href(["TARGET=\"main\""],"./result_frameset","Result")) + ]), + h2("Logs"), + ul([ + li(href(["TARGET=\"new\""],"/log_dir/index.html","Last Runs")), + li(href(["TARGET=\"new\""],"/log_dir/all_runs.html","All Runs")) + ]) + ]. + +config_frame1(State) -> + header("Config",body(config_body(State))). + +config_body(State) -> + Entry = [input("TYPE=file NAME=browse SIZE=40"), + input("TYPE=hidden NAME=file")], + AddForm = + form( + "NAME=read_file_form METHOD=post ACTION=\"./add_config_file\"", + table( + "BORDER=0", + [tr( + [td(Entry), + td("ALIGN=center", + input("TYPE=submit onClick=\"file.value=browse.value;\"" + " VALUE=\"Add\""))])])), + {Text,RemoveForm} = + case State#state.config of + [] -> + T = "To be able to run any tests, one or more configuration " + "files must be added. Enter the name of the configuration " + "file below and click the \"Add\" button.", + R = "", + {T,R}; + Files -> + T = "The currently known configuration files are listed below. " + "To add a file, type the filename in the entry and " + "click the \"Add\" button. " + "To remove a file, select it and click the \"Remove\" " + "button.", + ConfigFiles = [option(File) || File <- Files], + Select = select("NAME=file TITLE=\"Select Config File\"" + " MULTIPLE=true", + ConfigFiles), + R = + form(["NAME=remove_config METHOD=post ", + "ACTION=\"./remove_config_file\""], + table( + "BORDER=0", + [tr(td("ALIGN=center",Select)), + tr(td("ALIGN=center", + input("TYPE=submit VALUE=\"Remove\"")))])), + {T,R} + end, + + [h1("ALIGN=center","Config"), + table( + "WIDTH=600 ALIGN=center CELLPADDING=5", + [tr(td(["BGCOLOR=",?INFO_BG_COLOR],Text)), + tr(td("ALIGN=center",AddForm)), + tr(td("ALIGN=center",RemoveForm))])]. + + +add_config_file1(Input,State) -> + State1 = + case get_input_data(Input,"file") of + "" -> State; + File -> State#state{config=[File|State#state.config]} + end, + Return = config_frame1(State1), + {Return,State1}. + +remove_config_file1(Input,State) -> + Files = get_all_input_data(Input,"file"), + State1 = State#state{config=State#state.config--Files}, + Return = config_frame1(State1), + {Return,State1}. + + + +run_frame1(State) -> + header("Run Test",body(run_body(State))). + +run_body(#state{running=Running}) when Running>0 -> + [h1("ALIGN=center","Run Test"), + p(["Test are ongoing: ",href("./result_frameset","Results")])]; +run_body(State) -> + ConfigList = ul([li(File) || File <- State#state.config]), + ConfigFiles = [h3("Config Files"), + ConfigList], + + AddDirForm = + form( + "NAME=add_dir_form METHOD=post ACTION=\"./add_test_dir\"", + table( + "BORDER=0", + [tr(td("COLSPAN=2","Enter test directory")), + tr( + [td(input("TYPE=text NAME=dir SIZE=40")), + td("ALIGN=center", + input("TYPE=submit onClick=\"dir.value=browse.value;\"" + " VALUE=\"Add Test Dir\""))])])), + + {LoadedTestsTable,Submit} = + case create_testdir_entries(State#state.tests,1) of + [] -> {"",""}; + TestDirs -> + Heading = tr([th(""), + th("ALIGN=left","Directory"), + th("ALIGN=left","Suite"), + th("ALIGN=left","Case")]), + {table("CELLPADDING=5",[Heading,TestDirs]), + submit_button()} + end, + + %% It should be ok to have no config-file! + Body = + %% case State#state.config of %% [] -> %% p("ALIGN=center", + %% href("./config_frame","Please select one or + %% more config files")); %% _ -> + table( + "WIDTH=100%", + [tr(td(ConfigFiles)), + tr(td("")), + tr(td(AddDirForm)), + tr(td("")), + tr(td(LoadedTestsTable)), + tr(td(Submit))]), + %% end, + + [h1("ALIGN=center","Run Test"), Body]. + +create_testdir_entries([{Dir,Suite,Case}|Tests],N) -> + [testdir_entry(Dir,Suite,Case,N)|create_testdir_entries(Tests,N+1)]; +create_testdir_entries([],_N) -> + []. + +testdir_entry(Dir,Suite,Case,N) -> + NStr = integer_to_list(N), + tr([td(delete_button(NStr)), + td(Dir), + td(suite_select(Dir,Suite,NStr)), + td(case_select(Dir,Suite,Case,NStr))]). + +delete_button(N) -> + form(["NAME=remove_dir_form METHOD=post ACTION=\"./remove_test_dir\""], + [input(["TYPE=hidden NAME=dir VALUE=\'",N,"\'"]), + input(["TYPE=submit VALUE=X"])]). + +suite_select(Dir,Suite,N) -> + case filelib:wildcard(filename:join(Dir,"*_SUITE.erl")) of + [] -> + select("NAME=suite TITLE=\"Select suite\"",""); + Suites0 -> + Suites = [filename:basename(filename:rootname(S)) || S <- Suites0], + select("NAME=suite TITLE=\"Select suite\"", + options(["all"|Suites],atom_to_list(Suite),N,"select_suite")) + end. + +case_select(_Dir,all,_,N) -> + select("NAME=case TITLE=\"Select case\"", + options(["all"],"all",N,"select_case")); +case_select(Dir,Suite,Case,N) -> + MakeResult = + case application:get_env(common_test, auto_compile) of + {ok,false} -> + ok; + _ -> + UserInclude = + case application:get_env(common_test, include) of + {ok,UserInclDirs} when length(UserInclDirs) > 0 -> + [{i,UserInclDir} || UserInclDir <- UserInclDirs]; + _ -> + [] + end, + ct_run:run_make(Dir,Suite,UserInclude) + end, + case MakeResult of + ok -> + code:add_pathz(Dir), + case catch apply(Suite,all,[]) of + {'EXIT',Reason} -> + io:format("\n~p\n",[Reason]), + red(["COULD NOT READ TESTCASES!!",br(), + "See erlang shell for info"]); + {skip,_Reason} -> + select("NAME=case TITLE=\"Select case\"", + options(["all"],"all",N,"select_case")); + AllCasesAtoms -> + AllCases = [atom_to_list(C) || C <- AllCasesAtoms, + is_atom(C)], + select("NAME=case TITLE=\"Select case\"", + options(["all"|AllCases],atom_to_list(Case), + N,"select_case")) + end; + _Error -> + red(["COMPILATION ERROR!!",br(), + "See erlang shell for info",br(), + "Reload this page when errors are fixed"]) + end. + + +options([Selected|Elements],Selected,N,Func) -> + [option(["SELECTED ", + "onClick=\"document.location.href=\'./",Func,"?n=",N, + "&selected=",Selected,"\';\""], + Selected)| + options(Elements,Selected,N,Func)]; +options([Element|Elements],Selected,N,Func) -> + [option(["onClick=\"document.location.href=\'./",Func,"?n=",N, + "&selected=",Element,"\';\""], + Element)| + options(Elements,Selected,N,Func)]; +options([],_Selected,_N,_Func) -> + []. + +add_test_dir1(Input,State) -> + State1 = + case get_input_data(Input,"dir") of + "" -> State; + Dir0 -> + Dir = case ct_util:is_test_dir(Dir0) of + true -> + Dir0; + false -> filename:join(Dir0,"test") + end, + case filelib:is_dir(Dir) of + true -> + Test = ct_run:tests(Dir), + State#state{tests=State#state.tests++Test}; + false -> + State + end + end, + Return = run_frame1(State1), + {Return,State1}. + + + +remove_test_dir1(Input,State) -> + N = list_to_integer(get_input_data(Input,"dir")), + State1 = State#state{tests=delete_test(N,State#state.tests)}, + Return = run_frame1(State1), + {Return,State1}. + +delete_test(1,[_|T]) -> + T; +delete_test(N,[H|T]) -> + [H|delete_test(N-1,T)]. + +select_suite1(Input,State) -> + N = list_to_integer(get_input_data(Input,"n")), + Suite = list_to_atom(get_input_data(Input,"selected")), + Tests1 = replace_suite(N,Suite,State#state.tests), + State1 = State#state{tests=Tests1}, + Return = run_frame1(State1), + {Return,State1}. + +replace_suite(1,Suite,[{Dir,_,_}|T]) -> + [Test] = ct_run:tests(Dir,Suite), + [Test|T]; +replace_suite(N,Suite,[H|T]) -> + [H|replace_suite(N-1,Suite,T)]. + +select_case1(Input,State) -> + N = list_to_integer(get_input_data(Input,"n")), + Case = list_to_atom(get_input_data(Input,"selected")), + Tests1 = replace_case(N,Case,State#state.tests), + State1 = State#state{tests=Tests1}, + Return = run_frame1(State1), + {Return,State1}. + +replace_case(1,Case,[{Dir,Suite,_}|T]) -> + [Test] = ct_run:tests(Dir,Suite,Case), + [Test|T]; +replace_case(N,Case,[H|T]) -> + [H|replace_case(N-1,Case,T)]. + + +submit_button() -> + form(["NAME=run_test_form METHOD=post ACTION=\"./run_test\""], + [input("TYPE=submit VALUE=\"Run Test\"")]). + + +redirect_to_result_frameset1() -> + Head = + ["<META HTTP-EQUIV=\"refresh\" CONTENT=\"1; URL=./result_frameset\">"], + [header("",Head,body("Please wait..."))]. + +result_frameset1(State) -> + header("Results",result_frameset2(State)). + +result_frameset2(State) -> + ResultLog = + case {State#state.current_log_dir,State#state.running} of + {undefined,0} -> + "./no_result_log_frame"; + {undefined,_} -> + "./redirect_to_result_log_frame"; + {_Dir,0} -> + filename:join(["/log_dir","index.html"]); + {_Dir,_} -> + {_,CurrentLog} = hd(State#state.testruns), + CurrentLog + end, + frameset( + "COLS=\"200,*\"", + [frame(["NAME=\"result_summary\" SRC=\"./result_summary_frame\""]), + frame(["NAME=\"result_log\" SRC=\"",ResultLog,"\""])]). + +redirect_to_result_log_frame1(State) -> + ResultLog = + case {State#state.testruns,State#state.running} of + {[],0} -> + "./no_result_log_frame"; + {[],_} -> + "./redirect_to_result_log_frame"; + {[{_,CurrentLog}|_],_} -> + CurrentLog + end, + Head = ["<META HTTP-EQUIV=\"refresh\" CONTENT=\"1; URL=",ResultLog,"\">"], + [header("",Head,body("Please wait..."))]. + +result_summary_frame1(State) -> + case {State#state.running,State#state.reload_results} of + {0,false} -> + header("Result Summary",body(result_summary_body(State))); + _ -> + Head = + "<SCRIPT LANGUAGE=\"JavaScript1.2\">\n" + "\n" + "function startReloadInterval() {\n" + " intervalId = setInterval(\"reloadPage()\",5000)\n" + "}\n" + "\n" + "function reloadPage() {\n" + " location.reload()\n" + " parent.result_log.location.reload()\n" +% " parent.result_log.scrollBy(0, window.innerHeight)\n" + "}\n" + "</SCRIPT>\n", + header("Result Summary",Head, + body("onLoad=\"startReloadInterval()\" BGCOLOR=\"#FFFFFF\"", + result_summary_body(State))) + end. + +result_summary_body(State) -> + N = State#state.ok + State#state.fail + State#state.skip, + [h2("Result Summary"), + p([b(integer_to_list(N))," cases executed (of ", + b(integer_to_list(State#state.total)),")"]), + p([green([b(integer_to_list(State#state.ok))," successful"]),br(), + red([b(integer_to_list(State#state.fail))," failed"]),br(), + orange([b(integer_to_list(State#state.skip))," skipped"])]), + executed_test_list(State)]. + +executed_test_list(#state{testruns=[]}) -> + []; +executed_test_list(#state{testruns=TestRuns}) -> + [h2("Executed Tests"), + table( + "", + [tr(td(href("TARGET=\"result_log\"",Log,Name))) || + {Name,Log} <- lists:reverse(TestRuns)])]. + + +no_result_log_frame1() -> + header("Test Results",body(no_result_log_body())). + +no_result_log_body() -> + [h1("ALIGN=center","Test Results"), + p(["There are currently no test results available. ", + br(),href("TARGET=\"main\"","./run_frame","You can run tests here")])]. + +report1(tests_start,{TestName,_N},State) -> + {ok,LogDir} = ct_logs:get_log_dir(), + TestRuns = + case State#state.testruns of + [{TestName,_}|_]=TR -> + TR; + TR -> + [{TestName,get_test_log(TestName,LogDir)}|TR] + end, + State#state{testruns=TestRuns}; +report1(tests_done,{_Ok,_Fail,_Skip},State) -> + timer:send_after(5000, self(),stop_reload_results), + State#state{running=State#state.running-1,reload_results=true}; +report1(tc_start,{_Suite,_Case},State) -> + State; +report1(tc_done,{_Suite,init_per_suite,_},State) -> + State; +report1(tc_done,{_Suite,end_per_suite,_},State) -> + State; +report1(tc_done,{_Suite,_Case,ok},State) -> + State#state{ok=State#state.ok+1}; +report1(tc_done,{_Suite,_Case,{failed,_Reason}},State) -> + State#state{fail=State#state.fail+1}; +report1(tc_done,{_Suite,_Case,{skipped,_Reason}},State) -> + State#state{skip=State#state.skip+1}; +report1(tc_user_skip,{_Suite,_Case,_Reason},State) -> + State#state{skip=State#state.skip+1}. + +get_test_log(TestName,LogDir) -> + [Log] = + filelib:wildcard( + filename:join([TestName++".logs","run*","suite.log.html"])), + filename:join(["/log_dir",LogDir,Log]). + + + +%get_description(Suite,Case) -> +% case erlang:function_exported(Suite,Case,0) of +% true -> +% case catch apply(Suite,Case,[]) of +% {'EXIT',_Reason} -> +% "-"; +% Info -> +% case lists:keysearch(doc,1,Info) of +% {value,{doc,Doc}} when is_list(Doc) -> +% Doc; +% _ -> +% "-" +% end +% end; +% false -> +% "-" +% end. + +%%%----------------------------------------------------------------- +%%% Internal library +header(Body) -> + header("","",Body). +header(Title,Body) -> + header(Title,"",Body). +header(Title,Head,Body) -> + ["Pragma:no-cache\r\n", + "Content-type: text/html\r\n\r\n", + html_header(Title,Head,Body)]. + +html_header(Title,Head,Body) -> + ["<HTML>\n", + "<HEAD>\n", + "<TITLE>", Title, "</TITLE>\n", + Head, + "</HEAD>\n", + Body, + "</HTML>"]. + +body(Text) -> + ["<BODY BGCOLOR=\"#FFFFFF\">\n",Text,"<\BODY>\n"]. +body(Args,Text) -> + ["<BODY ", Args, ">\n", Text,"<\BODY>\n"]. + + +frameset(Args,Frames) -> + ["<FRAMESET ",Args,">\n", Frames, "\n</FRAMESET>\n"]. +frame(Args) -> + ["<FRAME ",Args, ">\n"]. + +table(Args,Text) -> + ["<TABLE ", Args, ">\n", Text, "\n</TABLE>\n"]. +tr(Text) -> + ["<TR>\n", Text, "\n</TR>\n"]. +tr(Args,Text) -> + ["<TR ", Args, ">\n", Text, "\n</TR>\n"]. +th(Text) -> + ["<TH>", Text, "</TH>"]. +th(Args,Text) -> + ["<TH ", Args, ">\n", Text, "\n</TH>\n"]. +td(Text) -> + ["<TD>", Text, "</TD>"]. +td(Args,Text) -> + ["<TD ", Args, ">", Text, "</TD>"]. + +b(Text) -> + ["<B>",Text,"</B>"]. +%em(Text) -> +% ["<EM>",Text,"</EM>\n"]. +%pre(Text) -> +% ["<PRE>",Text,"</PRE>"]. +href(Link,Text) -> + ["<A HREF=\"",Link,"\">",Text,"</A>"]. +href(Args,Link,Text) -> + ["<A HREF=\"",Link,"\" ",Args,">",Text,"</A>"]. +form(Args,Text) -> + ["<FORM ",Args,">\n",Text,"\n</FORM>\n"]. +input(Args) -> + ["<INPUT ", Args, ">\n"]. +select(Args,Text) -> + ["<SELECT ", Args, ">\n", Text, "\n</SELECT>\n"]. +option(Text) -> + ["<OPTION>\n", Text, "\n</OPTION>\n"]. +option(Args,Text) -> + ["<OPTION ", Args, ">\n", Text, "\n</OPTION>\n"]. +h1(Args,Text) -> + ["<H1 ", Args, ">",Text,"</H1>\n"]. +h2(Text) -> + ["<H2>",Text,"</H2>\n"]. +h3(Text) -> + ["<H3>",Text,"</H3>\n"]. +font(Args,Text) -> + ["<FONT ",Args,">\n",Text,"\n</FONT>\n"]. +p(Text) -> + ["<P>",Text,"</P>\n"]. +p(Args, Text) -> + ["<P ", Args, ">",Text,"</P>\n"]. +ul(Text) -> + ["<UL>", Text, "</UL>\n"]. +li(Text) -> + ["<LI>", Text, "</LI>\n"]. +br() -> + "<BR>\n". + +red(Text) -> color(red,Text). +green(Text) -> color(green,Text). +orange(Text) -> color(orange,Text). +color(Color,Text) when is_atom(Color) -> + font(["COLOR=",atom_to_list(Color)],Text). + +get_all_input_data(Input,Key)-> + List = parse(Input), + get_all_input_data(List,Key,[]). +get_all_input_data([{Key,Value}|List],Key,Acc) -> + get_all_input_data(List,Key,[Value|Acc]); +get_all_input_data([{_OtherKey,_Value}|List],Key,Acc) -> + get_all_input_data(List,Key,Acc); +get_all_input_data([],_Key,Acc) -> + Acc. + +get_input_data(Input,Key)-> + case lists:keysearch(Key,1,parse(Input)) of + {value,{Key,Value}} -> + Value; + false -> + undefined + end. + +parse(Input) -> + httpd:parse_query(Input). + |