%%--------------------------------------------------------------------
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2010-2017. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%----------------------------------------------------------------------
%% File : ct_config.erl
%% Description : CT module for reading and manipulating of configuration
%% data
%%
%% Created : 15 February 2010
%%----------------------------------------------------------------------
-module(ct_config).
-export([start/1, stop/0]).
-export([read_config_files/1,
get_config_file_list/1]).
-export([require/1, require/2]).
-export([get_config/1, get_config/2, get_config/3,
get_all_config/0]).
-export([set_default_config/2, set_default_config/3]).
-export([delete_default_config/1]).
-export([reload_config/1, update_config/2]).
-export([release_allocated/0]).
-export([encrypt_config_file/2, encrypt_config_file/3,
decrypt_config_file/2, decrypt_config_file/3,
get_crypt_key_from_file/0, get_crypt_key_from_file/1]).
-export([get_key_from_name/1]).
-export([check_config_files/1, add_default_callback/1, prepare_config_list/1]).
-export([add_config/2, remove_config/2]).
-include("ct_util.hrl").
-define(cryptfile, ".ct_config.crypt").
-record(ct_conf,{key,value,handler,config,name='_UNDEF',default=false}).
start(Mode) ->
case whereis(ct_config_server) of
undefined ->
Me = self(),
Pid = spawn_link(fun() -> do_start(Me) end),
receive
{Pid,started} -> Pid;
{Pid,Error} -> exit(Error)
end;
Pid ->
case ct_util:get_mode() of
interactive when Mode==interactive ->
Pid;
interactive ->
{error,interactive_mode};
_OtherMode ->
Pid
end
end.
do_start(Parent) ->
process_flag(trap_exit,true),
ct_util:mark_process(),
register(ct_config_server,self()),
ct_util:create_table(?attr_table,bag,#ct_conf.key),
{ok,StartDir} = file:get_cwd(),
Opts = case ct_util:read_opts() of
{ok,Opts1} ->
Opts1;
Error ->
Parent ! {self(),Error},
exit(Error)
end,
case read_config_files(Opts) of
ok ->
Parent ! {self(),started},
loop(StartDir);
ReadError ->
Parent ! {self(),ReadError},
exit(ReadError)
end.
stop() ->
case whereis(ct_config_server) of
undefined -> ok;
_ -> call({stop})
end.
call(Msg) ->
MRef = erlang:monitor(process, whereis(ct_config_server)),
Ref = make_ref(),
ct_config_server ! {Msg,{self(),Ref}},
receive
{Ref, Result} ->
erlang:demonitor(MRef, [flush]),
Result;
{'DOWN',MRef,process,_,Reason} ->
{error,{ct_util_server_down,Reason}}
end.
return({To,Ref},Result) ->
To ! {Ref, Result},
ok.
loop(StartDir) ->
receive
{{require,Name,Key},From} ->
Result = do_require(Name,Key),
return(From,Result),
loop(StartDir);
{{set_default_config,{Config,Scope}},From} ->
_ = set_config(Config,{true,Scope}),
return(From,ok),
loop(StartDir);
{{set_default_config,{Name,Config,Scope}},From} ->
_ = set_config(Name,Config,{true,Scope}),
return(From,ok),
loop(StartDir);
{{delete_default_config,Scope},From} ->
delete_config({true,Scope}),
return(From,ok),
loop(StartDir);
{{update_config,{Name,NewConfig}},From} ->
update_conf(Name,NewConfig),
return(From,ok),
loop(StartDir);
{{reload_config, KeyOrName},From}->
NewValue = reload_conf(KeyOrName),
return(From, NewValue),
loop(StartDir);
{{stop},From} ->
ets:delete(?attr_table),
ok = file:set_cwd(StartDir),
return(From,ok)
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}}).
reload_config(KeyOrName) ->
call({reload_config, KeyOrName}).
process_default_configs(Opts) ->
lists:flatmap(fun({config,[_|_] = FileOrFiles}) ->
case {io_lib:printable_unicode_list(FileOrFiles),
io_lib:printable_unicode_list(hd(FileOrFiles))} of
{false,true} ->
FileOrFiles;
{true,false} ->
[FileOrFiles];
_ ->
[]
end;
(_) ->
[]
end,Opts).
process_user_configs(Opts, Acc) ->
case lists:keytake(userconfig, 1, Opts) of
false ->
lists:reverse(Acc);
{value, {userconfig, Config=[{_,_}|_]}, NewOpts} ->
Acc1 = lists:map(fun({_Callback, []}=Cfg) ->
Cfg;
({Callback, Files=[File|_]}) when is_list(File) ->
{Callback, Files};
({Callback, File=[C|_]}) when is_integer(C) ->
{Callback, [File]}
end, Config),
process_user_configs(NewOpts, lists:reverse(Acc1)++Acc);
{value, {userconfig, {Callback, []}}, NewOpts} ->
process_user_configs(NewOpts, [{Callback, []} | Acc]);
{value, {userconfig, {Callback, Files=[File|_]}}, NewOpts} when is_list(File) ->
process_user_configs(NewOpts, [{Callback, Files} | Acc]);
{value, {userconfig, {Callback, File=[C|_]}}, NewOpts} when is_integer(C) ->
process_user_configs(NewOpts, [{Callback, [File]} | Acc])
end.
get_config_file_list(Opts) ->
DefaultConfigs = process_default_configs(Opts),
CfgFiles =
if
DefaultConfigs == [] ->
[];
true ->
[{?ct_config_txt, DefaultConfigs}]
end ++
process_user_configs(Opts, []),
CfgFiles.
add_default_callback(Opts) ->
case lists:keytake(config, 1, Opts) of
{value, {config, [File | _] = Files}, NoConfigOpts}
when is_integer(File) =/= true ->
[{config, lists:flatmap(fun add_def_cb/1, Files)} | NoConfigOpts];
{value, {config, File}, NoConfigOpts} ->
[{config, add_def_cb(File)} | NoConfigOpts];
false ->
Opts
end.
add_def_cb([]) ->
[];
add_def_cb(Config) when is_tuple(Config) ->
[Config];
add_def_cb([H|_T] = Config ) when is_integer(H) ->
[{?ct_config_txt, [Config]}].
read_config_files(Opts) ->
AddCallback = fun(CallBack, []) ->
[{CallBack, []}];
(CallBack, [F|_]=Files) when is_integer(F) ->
[{CallBack, Files}];
(CallBack, [F|_]=Files) when is_list(F) ->
lists:map(fun(X) -> {CallBack, X} end, Files)
end,
ConfigFiles = case lists:keyfind(config, 1, Opts) of
{config,ConfigLists} ->
lists:foldr(fun({Callback,Files}, Acc) ->
AddCallback(Callback,Files)
++ Acc
end,[],ConfigLists);
false ->
[]
end,
read_config_files_int(ConfigFiles, fun store_config/3).
read_config_files_int([{Callback, File}|Files], FunToSave) ->
case Callback:read_config(File) of
{ok, Config} ->
_ = FunToSave(Config, Callback, File),
read_config_files_int(Files, FunToSave);
{error, {ErrorName, ErrorDetail}} ->
{user_error, {ErrorName, File, ErrorDetail}};
{error, ErrorName, ErrorDetail} ->
{user_error, {ErrorName, File, ErrorDetail}}
end;
read_config_files_int([], _FunToSave) ->
ok.
read_config_files(ConfigFiles, FunToSave) ->
case read_config_files_int(ConfigFiles, FunToSave) of
{user_error, Error} ->
{error, Error};
ok ->
ok
end.
store_config(Config, Callback, File) when is_tuple(Config) ->
store_config([Config], Callback, File);
store_config(Config, Callback, File) when is_list(Config) ->
[ets:insert(?attr_table,
#ct_conf{key=Key,
value=Val,
handler=Callback,
config=File,
default=false}) ||
{Key,Val} <- Config].
keyfindall(Key, Pos, List) ->
[E || E <- List, element(Pos, E) =:= Key].
rewrite_config(Config, Callback, File) ->
OldRows = ets:match_object(?attr_table,
#ct_conf{handler=Callback,
config=File,_='_'}),
ets:match_delete(?attr_table,
#ct_conf{handler=Callback,
config=File,_='_'}),
Updater = fun({Key, Value}) ->
case keyfindall(Key, #ct_conf.key, OldRows) of
[] ->
ets:insert(?attr_table,
#ct_conf{key=Key,
value=Value,
handler=Callback,
config=File});
RowsToUpdate ->
Inserter = fun(Row) ->
ets:insert(?attr_table,
Row#ct_conf{value=Value})
end,
lists:foreach(Inserter, RowsToUpdate)
end
end,
[Updater({Key, Value})||{Key, Value}<-Config].
set_config(Config,Default) ->
set_config('_UNDEF',Config,Default).
set_config(Name,Config,Default) ->
[ets:insert(?attr_table,
#ct_conf{key=Key,value=Val,
name=Name,default=Default}) ||
{Key,Val} <- Config].
get_config(KeyOrName) ->
get_config(KeyOrName,undefined,[]).
get_config(KeyOrName,Default) ->
get_config(KeyOrName,Default,[]).
get_config(KeyOrName,Default,Opts) when is_atom(KeyOrName) ->
case get_config({KeyOrName}, Default, Opts) of
%% If only an atom is given, then we need to unwrap the
%% key if it is returned
{{KeyOrName}, Val} ->
{KeyOrName, Val};
[{{KeyOrName}, _Val}|_] = Res ->
[{K, Val} || {{K},Val} <- Res, K == KeyOrName];
Else ->
Else
end;
%% This useage of get_config is only used by internal ct functions
%% and may change at any time
get_config({DeepKey,SubKey}, Default, Opts) when is_tuple(DeepKey) ->
get_config(erlang:append_element(DeepKey, SubKey), Default, Opts);
get_config(KeyOrName,Default,Opts) when is_tuple(KeyOrName) ->
case lookup_config(element(1,KeyOrName)) of
[] ->
format_value([Default],KeyOrName,Opts);
Vals ->
NewVals =
lists:map(
fun({Val}) ->
get_config(tl(tuple_to_list(KeyOrName)),
Val,Default,Opts)
end,Vals),
format_value(NewVals,KeyOrName,Opts)
end.
get_config([],Vals,_Default,_Opts) ->
Vals;
get_config([[]],Vals,Default,Opts) ->
get_config([],Vals,Default,Opts);
%% This case is used by {require,{unix,[port,host]}} functionality
get_config([SubKeys], Vals, Default, _Opts) when is_list(SubKeys) ->
case do_get_config(SubKeys, Vals, []) of
{ok, SubVals} ->
[SubVal || {_,SubVal} <- SubVals];
_ ->
Default
end;
get_config([Key|Rest], Vals, Default, Opts) ->
case do_get_config([Key], Vals, []) of
{ok, [{Key,NewVals}]} ->
get_config(Rest, NewVals, Default, Opts);
_ ->
Default
end.
do_get_config([Key|_], Available, _Mapped) when not is_list(Available) ->
{error,{not_available,Key}};
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{value='$1',name=Name,_='_'},
[],[{{'$1'}}]}]).
lookup_key(Key) ->
ets:select(?attr_table,[{#ct_conf{key=Key,value='$1',name='_UNDEF',_='_'},
[],[{{'$1'}}]}]).
format_value([SubVal|_] = SubVals, KeyOrName, Opts) ->
case {lists:member(all,Opts),lists:member(element,Opts)} of
{true,true} ->
[{KeyOrName,Val} || Val <- SubVals];
{true,false} ->
[Val || Val <- SubVals];
{false,true} ->
{KeyOrName,SubVal};
{false,false} ->
SubVal
end.
lookup_handler_for_config({Key, _Subkey}) ->
lookup_handler_for_config(Key);
lookup_handler_for_config(KeyOrName) ->
case lookup_handler_for_name(KeyOrName) of
[] ->
lookup_handler_for_key(KeyOrName);
Values ->
Values
end.
lookup_handler_for_name(Name) ->
ets:select(?attr_table,[{#ct_conf{handler='$1',config='$2',name=Name,_='_'},
[],
[{{'$1','$2'}}]}]).
lookup_handler_for_key(Key) ->
ets:select(?attr_table,[{#ct_conf{handler='$1',config='$2',key=Key,_='_'},
[],
[{{'$1','$2'}}]}]).
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.
reload_conf(KeyOrName) ->
case lookup_handler_for_config(KeyOrName) of
[] ->
undefined;
HandlerList ->
HandlerList2 = lists:usort(HandlerList),
case read_config_files(HandlerList2, fun rewrite_config/3) of
ok ->
get_config(KeyOrName);
Error ->
Error
end
end.
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.
allocate(Name,Key) ->
Ref = make_ref(),
case get_config(Key,Ref,[all,element]) of
[{_,Ref}] ->
{error,{not_available,Key}};
Configs ->
associate(Name,Key,Configs),
ok
end.
associate('_UNDEF',_Key,_Configs) ->
ok;
associate(Name,{Key,SubKeys},Configs) when is_atom(Key), is_list(SubKeys) ->
associate_int(Name,Configs,"true");
associate(Name,_Key,Configs) ->
associate_int(Name,Configs,os:getenv("COMMON_TEST_ALIAS_TOP")).
associate_int(Name,Configs,"true") ->
lists:foreach(fun({K,_Config}) ->
Cs = ets:match_object(
?attr_table,
#ct_conf{key=element(1,K),
name='_UNDEF',_='_'}),
[ets:insert(?attr_table,C#ct_conf{name=Name})
|| C <- Cs]
end,Configs);
associate_int(Name,Configs,_) ->
lists:foreach(fun({K,Config}) ->
Key = if is_tuple(K) -> element(1,K);
is_atom(K) -> K
end,
Cs = ets:match_object(
?attr_table,
#ct_conf{key=Key,
name='_UNDEF',_='_'}),
[ets:insert(?attr_table,C#ct_conf{name=Name,
value=Config})
|| C <- Cs]
end,Configs).
delete_config(Default) ->
ets:match_delete(?attr_table,#ct_conf{default=Default,_='_'}),
ok.
require(Key) when is_atom(Key); is_tuple(Key) ->
allocate('_UNDEF',Key);
require(Key) ->
{error,{invalid,Key}}.
require(Name,Key) when is_atom(Name),is_atom(Key) orelse is_tuple(Key) ->
call({require,Name,Key});
require(Name,Keys) ->
{error,{invalid,{Name,Keys}}}.
do_require(Name,Key) ->
case get_key_from_name(Name) of
{error,_} ->
allocate(Name,Key);
{ok,NameKey} when NameKey == Key;
is_tuple(Key) andalso element(1,Key) == NameKey ->
%% already allocated - check that it has all required subkeys
R = make_ref(),
case get_config(Key,R,[]) of
R ->
{error,{not_available,Key}};
{error,_} = Error ->
Error;
_Error ->
ok
end;
{ok,OtherKey} ->
{error,{name_in_use,Name,OtherKey}}
end.
encrypt_config_file(SrcFileName, EncryptFileName) ->
case get_crypt_key_from_file() of
{error,_} = E ->
E;
Key ->
encrypt_config_file(SrcFileName, EncryptFileName, {key,Key})
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.
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(),
{Key,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:block_encrypt(des3_cbc, Key, IVec, Bin2),
case file:write_file(EncryptFileName, EncBin) of
ok ->
io:format("~ts --(encrypt)--> ~ts~n",
[SrcFileName,EncryptFileName]),
ok;
{error,Reason} ->
{error,{Reason,EncryptFileName}}
end;
{error,Reason} ->
{error,{Reason,SrcFileName}}
end.
decrypt_config_file(EncryptFileName, TargetFileName) ->
case get_crypt_key_from_file() of
{error,_} = E ->
E;
Key ->
decrypt_config_file(EncryptFileName, TargetFileName, {key,Key})
end.
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(),
{Key,IVec} = make_crypto_key(Key),
case file:read_file(EncryptFileName) of
{ok,Bin} ->
DecBin = crypto:block_decrypt(des3_cbc, Key, 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("~ts --(decrypt)--> ~ts~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:lexemes(binary_to_list(Bin), [$\n, [$\r,$\n]]) 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:lexemes(binary_to_list(Result), [$\n, [$\r,$\n]]) of
[Key] ->
io:format("~nCrypt key file: ~ts~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) ->
random_bytes_1(N, []).
random_bytes_1(0, Acc) -> Acc;
random_bytes_1(N, Acc) -> random_bytes_1(N-1, [rand:uniform(255)|Acc]).
check_callback_load(Callback) ->
case code:is_loaded(Callback) of
{file, _Filename} ->
check_exports(Callback);
false ->
case code:load_file(Callback) of
{module, Callback} ->
check_exports(Callback);
{error, Error} ->
{error, Error}
end
end.
check_exports(Callback) ->
Fs = Callback:module_info(exports),
case {lists:member({check_parameter,1},Fs),
lists:member({read_config,1},Fs)} of
{true, true} ->
{ok, Callback};
_ ->
{error, missing_callback_functions}
end.
check_config_files(Configs) ->
ConfigChecker = fun
({Callback, [F|_R]=Files}) ->
case check_callback_load(Callback) of
{ok, Callback} ->
if is_integer(F) ->
Callback:check_parameter(Files);
is_list(F) ->
lists:map(fun(File) ->
Callback:check_parameter(File)
end,
Files)
end;
{error, Why} ->
{error, {callback, {Callback,Why}}}
end;
({Callback, []}) ->
case check_callback_load(Callback) of
{ok, Callback} ->
Callback:check_parameter([]);
{error, Why} ->
{error, {callback, {Callback,Why}}}
end
end,
lists:keysearch(error, 1, lists:flatten(lists:map(ConfigChecker, Configs))).
prepare_user_configs([CallbackMod|UserConfigs], Acc, new) ->
prepare_user_configs(UserConfigs,
[{list_to_atom(CallbackMod),[]}|Acc],
cur);
prepare_user_configs(["and"|UserConfigs], Acc, _) ->
prepare_user_configs(UserConfigs, Acc, new);
prepare_user_configs([ConfigString|UserConfigs], [{LastMod,LastList}|Acc], cur) ->
prepare_user_configs(UserConfigs,
[{LastMod, [ConfigString|LastList]}|Acc],
cur);
prepare_user_configs([], Acc, _) ->
Acc.
prepare_config_list(Args) ->
ConfigFiles = case lists:keysearch(ct_config, 1, Args) of
{value,{ct_config,Files}} ->
[{?ct_config_txt,[filename:absname(F) || F <- Files]}];
false ->
[]
end,
UserConfigs = case lists:keysearch(userconfig, 1, Args) of
{value,{userconfig,UserConfigFiles}} ->
prepare_user_configs(UserConfigFiles, [], new);
false ->
[]
end,
ConfigFiles ++ UserConfigs.
% TODO: add logging of the loaded configuration file to the CT FW log!!!
add_config(Callback, []) ->
read_config_files([{Callback, []}], fun store_config/3);
add_config(Callback, [File|_Files]=Config) when is_list(File) ->
lists:foreach(fun(CfgStr) ->
read_config_files([{Callback, CfgStr}], fun store_config/3) end,
Config);
add_config(Callback, [C|_]=Config) when is_integer(C) ->
read_config_files([{Callback, Config}], fun store_config/3).
remove_config(Callback, Config) ->
ets:match_delete(?attr_table,
#ct_conf{handler=Callback,
config=Config,_='_'}),
ok.
