keep tokens and their modules in maps

For convenient lookup by name. Not the most storage efficient, and
maybe proplists would be better suited. Learning maps is useful
though.

2 files changed, 73 insertions, 38 deletions

diff --git a/p11p-daemon/src/p11p_config.erl b/p11p-daemon/src/p11p_config.erl
index 58ea618..e9279f3 100644
--- a/p11p-daemon/src/p11p_config.erl
+++ b/p11p-daemon/src/p11p_config.erl
@@ -3,7 +3,8 @@
 
 %% API
 -export([start_link/0]).
--export([config/0]).
+%%-export([config/0]).
+-export([nameof/1]).
 -export([tokens/0]).
 -export([modules_for_token/1]).
 
@@ -14,35 +15,47 @@
 %% Records and types.
 -record(p11module, {
 	  name :: string(),
-          path :: string()
+          path :: string()			%FIXME: filename
 	  }).
 -type p11module() :: #p11module{}.
 
 -record(token, {
 	  name :: string(),
-	  modules = [] :: [p11module()]
+	  modules = #{} :: #{string() => p11module()}
 	 }).
 -type token() :: #token{}.
 
 %% Genserver state.
--record(state, { tokens :: [token()] }).
+-record(state, {
+	  tokens :: #{string() => token()}
+	 }).
 
 %%%%%%%%%%%%%%%%%%%%
 %% API.
 start_link() ->
     gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
 
-config() ->
-    gen_server:call(?MODULE, config).
+%% config() ->
+%%     gen_server:call(?MODULE, config).
 
--spec tokens() -> [string()].
+-spec tokens() -> [token()].
 tokens() ->
-    [T#token.name || T <- gen_server:call(?MODULE, tokens)].
+    gen_server:call(?MODULE, tokens).
 
--spec modules_for_token(token()) -> [p11module()].
+-spec modules_for_token(string()) -> [module()].
 modules_for_token(Token) ->
     gen_server:call(?MODULE, {modules_for_token, Token}).
 
+%% -spec module_path(string()) -> string().
+%% module_path(Module) ->
+%%     Module#p11module.path.
+
+nameof(#token{name = Name}) ->
+    Name;
+nameof(#p11module{name = Name}) ->
+    Name;
+nameof(List) ->
+    [nameof(E) || E <- List].
 
 %%%%%%%%%%%%%%%%%%%%
 %% Genserver callbacks.
@@ -50,14 +63,13 @@ init(_Args) ->
     State = init_state(),
     {ok, State}.
 
-handle_call(config, _From, State) ->
-    {reply, State, State};
+%% handle_call(config, _From, State) ->
+%%     {reply, State, State};
 handle_call(tokens, _From, #state{tokens = Tokens} = State) ->
-    {reply, Tokens, State};
-handle_call({modules_for_token, _Token}, _From,
-	    #state{tokens = _Tokens} = State) ->
-    Reply = [#p11module{name="FIXME", path="FIXME"}],
-    {reply, Reply, State};
+    {reply, maps:values(Tokens), State};
+handle_call({modules_for_token, TokenString}, _, #state{tokens = Tokens} = S) ->
+    #{TokenString := Token} = Tokens,
+    {reply, maps:values(Token#token.modules), S};
 handle_call(Request, _From, State) ->
     lager:warning("Unhandled call: ~p", [Request]),
     {reply, unhandled, State}.
@@ -81,20 +93,31 @@ code_change(_OldVersion, State, _Extra) ->
 
 init_state() ->
     #state { 
-       tokens = init_tokens(application:get_env(p11p, groups, []))
+       tokens = conf_tokens(application:get_env(p11p, groups, []))
       }.
 
-init_tokens(Tokens) ->
-    [new_token(T) || T <- Tokens].
+conf_tokens(L) ->
+    conf_tokens(L, #{}).
+conf_tokens([], Acc) ->
+    Acc;
+conf_tokens([H = {Name, _}|T], Acc) ->
+    conf_tokens(T, Acc#{Name => new_token(H)}).
 
 -spec new_token({string(), [tuple()]}) -> token().
 new_token({Name, Settings}) ->
     #token{
        name = Name,
-       modules = [new_module(M) || M <- proplists:get_value(modules, Settings, [])]
+       modules = conf_modules(proplists:get_value(modules, Settings))
       }.
 
-new_module({Name, Path}) ->
+conf_modules(L) ->
+    conf_modules(L, #{}).
+conf_modules([], Acc) ->
+    Acc;
+conf_modules([{Name, Path}|T], Acc) ->
+    conf_modules(T, Acc#{Name => new_module(Name, Path)}).
+
+new_module(Name, Path) ->
     #p11module{
        name = Name,
        path = Path
@@ -105,23 +128,35 @@ new_module({Name, Path}) ->
 
 -include_lib("eunit/include/eunit.hrl").
 
-tokens_test_() ->
+tokens_init_test_() ->
     {setup,
-     fun() -> init_tokens(
-		[
-		 {"vtoken0", 
-		  [{modules, [{"bogusmod0_0", "/path/to/bogusmod0_0"},
-			      {"bogusmod0_1", "/path/to/bogusmod0_1"}
-			     ]}]},
-		 {"vtoken1",
-		  [{modules, [{"bogusmod1_0", "/path/to/bogusmod1_0"}]}]}
-		]) end,
+     fun() ->
+	     conf_tokens(
+	       [
+		{"vtoken0", 
+		 [{modules, [{"bogusmod0_0", "/path/to/bogusmod0_0"},
+			     {"bogusmod0_1", "/path/to/bogusmod0_1"}
+			    ]}]},
+		{"vtoken1",
+		 [{modules, [{"bogusmod1_0", "/path/to/bogusmod1_0"}]}]}
+	       ]) end,
      fun(_) -> ok end,
      fun(Conf) ->
              [?_assertEqual(
-                 [
-		  {token,"vtoken0",[{p11module,"bogusmod0_0", "/path/to/bogusmod0_0"},
-				    {p11module,"bogusmod0_1", "/path/to/bogusmod0_1"}]},
-		  {token,"vtoken1",[{p11module,"bogusmod1_0", "/path/to/bogusmod1_0"}]}
-		 ],
+                 #{"vtoken0" =>
+		       {token,"vtoken0",
+			#{"bogusmod0_0" => 
+			      {p11module,"bogusmod0_0", "/path/to/bogusmod0_0"},
+			  "bogusmod0_1" => 
+			      {p11module,"bogusmod0_1", "/path/to/bogusmod0_1"}}},
+		   "vtoken1" =>
+		       {token,"vtoken1",
+			#{"bogusmod1_0" =>
+			      {p11module,"bogusmod1_0", "/path/to/bogusmod1_0"}}}
+		  },
 		 Conf)] end}.
+%% modules_for_token_test_() ->
+%%     {setup,
+%%      fun() ->
+	     
+	     
diff --git a/p11p-daemon/src/p11p_server_sup.erl b/p11p-daemon/src/p11p_server_sup.erl
index c73346a..b38ea51 100644
--- a/p11p-daemon/src/p11p_server_sup.erl
+++ b/p11p-daemon/src/p11p_server_sup.erl
@@ -8,7 +8,7 @@ start_link() ->
     supervisor:start_link({local, ?MODULE}, ?MODULE, []).
 
 init([]) ->
-    ok = start_servers(p11p_config:tokens()),
+    ok = start_servers(p11p_config:nameof(p11p_config:tokens())),
     {ok, {{simple_one_for_one, 1, 5},
 	  [{sock_server,
 	    {p11p_server, start_link, []},
@@ -20,7 +20,7 @@ start_server(Args) ->
     Pid.
 
 cleanup() ->
-    cleanup(p11p_config:tokens()).
+    cleanup(p11p_config:nameof(p11p_config:tokens())).
 
 %% Private functions.
 start_servers([]) ->