backup 6-5-2013

ref.erl

@@ -0,0 +1,44 @@
+-module(ref).
+
+-export([init/1,
+	 handle_call/3,
+	 handle_cast/2,
+	 handle_info/2,
+	 terminate/2,
+	 code_change/3]).
+
+-export([new_ref/0
+	 ]).
+
+-compile(export_all).
+
+-behaviour(gen_server).
+
+-define(SERVER,?MODULE).
+
+-record(state,{ref_num}).
+
+start() ->
+    gen_server:start_link({global,?SERVER},?MODULE,[],[]).
+
+new_ref() ->
+    gen_server:call({global,?SERVER},mr).
+
+init([]) ->
+    {ok,#state{ref_num=0}}.
+
+handle_cast(_Msg, State) ->
+    {noreply,State}.    
+
+handle_call(mr,_From,State) ->
+    Ref_num = State#state.ref_num,
+    {reply,make_ref(),State#state{ref_num = Ref_num+1}}.
+
+handle_info(_Msg,State) ->
+    {noreply,State}.
+
+terminate(_Reason,_State) ->
+    ok.
+
+code_change(_OldVsn,State,_Extra) ->
+    {ok,State}.

runes.app

@@ -10,6 +10,6 @@
 	      runes
 	      ]},
    {registered,[runes_sup]},
-   {application,[kernel,stdlib]},
+   {application,[kernel,stdlib,mnesia,resource_discovery]},
    {mod, {runes_app,[]}}
    ]}.

runes.erl

@@ -24,11 +24,17 @@ add_fact(Fact) ->
 
 info() ->
     runes_agenda:show_working_memory(),
+    io:format("All classes: ~p~n",[runes_agenda:get_class_set(node())]),
     runes_agenda:get_node_num(all_nodes).
 
 fire() ->
-    runes_agenda:get_conflict_set().
-
+    [_|T] = nodes(),
+    Nodes = [node()|T],
+    lists:map(fun(N) ->
+		      {ok,CSet} = runes_agenda:get_conflict_set(N),
+		      io:format("the length of conflict_set at ~p: ~p~n",[N,length(CSet)]),
+		      {N,CSet}
+	      end,Nodes).
 
 
 

runes_agenda.erl

@@ -8,39 +8,62 @@
 	 code_change/3]).
 
 -export([start/0,
-	 get_conflict_set/0,
+	 get_conflict_set/1,
+	 get_class_set/1,
+	 get_process_set/1,
+	 silent/1,
+	 create_node/3,
 	 put_pn/2,
 	 get_pn/1,
 	 delete_rn/1,
-	 get_root/0,
+	 get_root_and_set_class/2,
 	 get_node_num/1,
 	 inc_node_num/1,
 	 dec_node_num/1,
 	 show_working_memory/0,
+	 get_all_processes/0,
 	 fire_able/2]).
 
 -compile(export_all).
 
 -behaviour(gen_server).
 
+-define(SERVER,agenda).
 
--record(agenda, {conflict_set}).
+
+-record(agenda, {conflict_set,class_set,process_set}).
 
 start() ->
     {ok,Agenda} = gen_server:start_link(?MODULE,[],[]),
     register(agenda,Agenda).
 
+create_node(Where,Type,Paras) ->
+    gen_server:call({agenda,Where},{new,Type,Paras}).
+
+get_root_and_set_class(Where,Class) ->
+    gen_server:call({agenda,Where},{root,Class}).
+
+get_dummy_top_node(Where) ->
+    gen_server:call({agenda,Where},dtn).
+
 fire_able(Pn,_State) ->
-    gen_server:cast(agenda,{fa,Pn}).
+    gen_server:cast({agenda,node()},{fa,Pn}).
+
+get_conflict_set(Where) ->
+    gen_server:call({agenda,Where},get_cs).
+
+get_class_set(Where) ->
+    gen_server:call({agenda,Where},get_cls).
+
+get_process_set(Where) ->
+    gen_server:call({agenda,Where},get_ps).
 
-get_conflict_set() ->
-    gen_server:call(agenda,get_cs).
+silent(Where) ->
+    gen_server:call({agenda,Where},silent).
 
 
 init([]) ->
     ets:new(agenda, [public,named_table,{read_concurrency,true}]),
-%    ets:new(am,[public,named_table,{read_concurrency,true}]),
-%    ets:new(bm,[public,named_table,{read_concurrency,true}]),
     Root = runes_compile:build_root_node_only_once(),
     Dummy_top_node = runes_compile:build_dummy_top_node_only_once(),
     ets:insert(agenda,{dummy_top_node,Dummy_top_node}),
@@ -50,18 +73,51 @@ init([]) ->
     ets:insert(agenda,{ctn_num,0}),
     ets:insert(agenda,{pn_num,0}),
     ets:insert(agenda,{jn_num,0}),
-    {ok,#agenda{conflict_set=[]}}.
+    {ok,#agenda{conflict_set=[],class_set=[],process_set=[]}}.
 
 handle_cast({fa,Pn},State) ->
     Cset0 = State#agenda.conflict_set,
     Cset1 = [Pn|Cset0],
-    {noreply,#agenda{conflict_set=Cset1}}.
+    {noreply,State#agenda{conflict_set=Cset1}}.
+
+handle_call({new,Type,Paras},_From,State) ->
+    inc_node_num(Type),
+    {ok,Pro} = runes_engine:create(Type,Paras),
+    Pset0 = State#agenda.process_set,
+    {reply,{ok,Pro},State#agenda{process_set=[Pro|Pset0]}};
+
+handle_call({root,Class},_From,State) ->
+    Old_Classes = State#agenda.class_set,
+    Where = runes_kb:find_class(Class),
+    if Where =:= no_class ->
+	    runes_kb:insert(class,Class,node()),
+	    {reply,
+	     get_rn(),
+	     State#agenda{class_set = [Class|Old_Classes]}};
+       true ->
+	    {reply,get_rn(),State}
+    end;
+
+handle_call(dtn,_From,State) ->
+    {reply,get_dtn(),State};
 
 handle_call(get_cs,_From,State) ->
     Set= State#agenda.conflict_set,
-    io:format("the length of conflict_set: ~p~n", [length(Set)]),
-    {reply,{ok,Set},State}.
+    %io:format("the length of conflict_set: ~p~n", [length(Set)]),
+    {reply,{ok,Set},State};
 
+handle_call(get_ps,_From,State) ->
+    {reply,{ok,State#agenda.process_set},State};
+
+handle_call(get_cls,_From,State) ->
+    {reply,{ok,State#agenda.class_set},State};
+
+handle_call(silent,_From,State) ->
+    Pl = State#agenda.process_set,
+   % io:format("~p ps: ~p~n",[self(),Pl]),
+    {reply,isnull(Pl),State}.
+
+
 handle_info(_Msg,State) ->
     {noreply,State}.
 
@@ -72,15 +128,15 @@ code_change(_OldVsn,State,_Extra) ->
     {ok,State}.
 
 
-get_root() ->
+get_rn() ->
     case ets:lookup(agenda,root_node) of
 	[{root_node,Root}] ->
 	    {ok,Root};
 	[] ->
 	    no_root
     end.
 
-get_dummy_top_node() ->
+get_dtn() ->
     case ets:lookup(agenda,dummy_top_node) of
 	[{dummy_top_node,Dn}] ->
 	    {ok,Dn};
@@ -103,8 +159,38 @@ delete_rn(Rn) ->
 
 show_working_memory() ->
     io:format("All wme_refs: ~p~n",[runes_kb:get_all_wme_refs()]),
-    Trs = lists:flatten(ets:match(token_store,{'$1','_'})),
-    io:format("All token_refs: ~p~n",[Trs]).
+    io:format("All token_refs: ~p~n",[runes_kb:get_all_token_refs()]).
+
+get_all_processes() ->
+    [_|T] = nodes(),
+    Nodes = [node()|T],
+    lists:flatmap(fun(N) ->
+			  {ok,Ps} = get_process_set(N),
+			  Ps
+		  end,Nodes).
+
+
+loop(Pl) ->
+    T2 = erlang:now(),
+    Null = silent(Pl),
+    io:format("~p",[z]),
+    if Null ->
+	    T3 = erlang:now(),
+	    {T2,T3};
+       true ->
+	    loop(Pl)
+    end.
+
+isnull([]) ->
+    true;
+isnull([P|Pl]) ->
+    Len = proplists:get_value(message_queue_len,process_info(P),1),
+   % io:format("Len: ~p",[Len]),
+    if Len /= 0 ->
+	    false;
+       true ->
+	    isnull(Pl)
+    end.
 
 get_node_num(all_nodes) ->
     Ls = lists:map(fun(Class) ->

runes_app.erl

@@ -4,10 +4,19 @@
 
 -export([start/2,stop/1]).
 
+-define(WAIT_FOR_RESOURCES,2500).
+
 start(_StartType, _StartArgs) ->
+    ok = ensure_contact(),
+    resource_discovery:add_local_resource(runes,node()),
+    resource_discovery:add_target_resource_type(runes),
+    resource_discovery:trade_resources(),
+    timer:sleep(?WAIT_FOR_RESOURCES),
     runes_kb:init(),
+    io:format("success"),
     case runes_sup:start_link() of
 	{ok,Pid} ->
+	    io:format("success"),
 	    runes_agenda:start(),
 	    {ok, Pid};
 	Other->
@@ -16,3 +25,45 @@ start(_StartType, _StartArgs) ->
 
 stop(_State) ->
     ok.
+
+ensure_contact() ->
+    DefaultNodes = ['contact@202.38.95.139'],
+    case get_env(runes, contact_nodes, DefaultNodes) of
+        [] ->
+            {error, no_contact_nodes};
+        ContactNodes ->
+            ensure_contact(ContactNodes)
+    end.
+
+ensure_contact(ContactNodes) ->
+    Answering = [N || N <- ContactNodes, net_adm:ping(N) =:= pong],
+    case Answering of
+        [] ->
+            {error, no_contact_nodes_reachable};
+        _ ->
+            DefaultTime = 3000,
+            WaitTime = get_env(runes, wait_time, DefaultTime),
+            wait_for_nodes(length(Answering), WaitTime)
+    end.
+
+wait_for_nodes(MinNodes, WaitTime) ->
+    Slices = 10,
+    SliceTime = round(WaitTime/Slices),
+    wait_for_nodes(MinNodes, SliceTime, Slices).
+
+wait_for_nodes(_MinNodes, _SliceTime, 0) ->
+    ok;
+wait_for_nodes(MinNodes, SliceTime, Iterations) ->
+    case length(nodes()) > MinNodes of
+        true ->
+          ok;
+        false ->
+            timer:sleep(SliceTime),
+            wait_for_nodes(MinNodes, SliceTime, Iterations - 1)
+    end.
+
+get_env(AppName, Key, Default) ->
+    case application:get_env(AppName, Key) of
+        undefined   -> Default;
+        {ok, Value} -> Value
+    end.