capricorn 0.2.25 → 2.0.0

data/erlang/lib/emq/src/emq_sup.erl

@@ -0,0 +1,132 @@
+-module(emq_sup).
+-behaviour(supervisor).
+
+-export([start_link/0, stop/0]).
+-export([start_queue/2, setup_process/6, get_emq/1, get_queue/1, get_pool/1, get_status/1]).
+-export([init/1]).
+
+start_link() ->
+  supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+stop() ->
+  erlang:exit(whereis(?MODULE), normal).
+
+start_queue(Name, Options) ->
+  Result = supervisor:start_child(?MODULE, {
+    Name,
+    {emq, start_link, [[{name, Name}| Options]]},
+    permanent,
+    5000,
+    worker,
+    [emq]
+  }),
+  case Result of
+  {ok, _Pid, _Info} ->
+    {ok, Name};
+  {ok, _Pid} ->
+    {ok, Name};
+  {error, Reason} ->
+    {error, Reason}
+  end.
+
+
+
+setup_process(Pid, Name, Emq, Queue, Pool, Status) ->
+  gen_server:call(Pid, {setup_process, Name, Emq, Queue, Pool, Status}).
+
+
+
+get_emq(local) ->
+  {ok, erlang:get('$emq')};
+
+get_emq({remote, Name}) ->
+  Children = supervisor:which_children(?MODULE),
+  lists:foldl(fun
+  ({ChildName, Pid, worker, [emq]}, _) when Name == ChildName ->
+    {ok, Pid};
+  (_, Acc) ->
+    Acc
+  end, {error, not_found}, Children);
+
+get_emq(Name) ->
+  case erlang:get('$emq_name') of
+  MyName when MyName == Name ->
+    get_emq(local);
+  _Else ->
+    get_emq({remote, Name})
+  end.
+
+
+
+get_queue(local) ->
+  {ok, erlang:get('$emq_queue')};
+
+get_queue({remote, Name}) ->
+  case get_emq({remote, Name}) of
+  {ok, Pid} ->
+    case gen_server:call(Pid, {'$emq_internal_info'}) of
+    {ok, {Name, _Pool, Queue, _Status}} -> {ok, Queue};
+    {error, Reason} -> {error, Reason}
+    end;
+  {error, Reason} -> {error, Reason}
+  end;
+
+get_queue(Name) ->
+  case erlang:get('$emq_name') of
+  MyName when MyName == Name ->
+    get_queue(local);
+  _Else ->
+    get_queue({remote, Name})
+  end.
+
+
+
+get_pool(local) ->
+  {ok, erlang:get('$emq_pool')};
+
+get_pool({remote, Name}) ->
+  case get_emq({remote, Name}) of
+  {ok, Pid} ->
+    case gen_server:call(Pid, {'$emq_internal_info'}) of
+    {ok, {Name, Pool, _Queue, _Status}} -> {ok, Pool};
+    {error, Reason} -> {error, Reason}
+    end;
+  {error, Reason} -> {error, Reason}
+  end;
+
+get_pool(Name) ->
+  case erlang:get('$emq_name') of
+  MyName when MyName == Name ->
+    get_pool(local);
+  _Else ->
+    get_pool({remote, Name})
+  end.
+
+
+
+get_status(local) ->
+  {ok, erlang:get('$emq_status')};
+
+get_status({remote, Name}) ->
+  case get_emq({remote, Name}) of
+  {ok, Pid} ->
+    case gen_server:call(Pid, {'$emq_internal_info'}) of
+    {ok, {Name, _Pool, _Queue, Status}} -> {ok, Status};
+    {error, Reason} -> {error, Reason}
+    end;
+  {error, Reason} -> {error, Reason}
+  end;
+
+get_status(Name) ->
+  case erlang:get('$emq_name') of
+  MyName when MyName == Name ->
+    get_status(local);
+  _Else ->
+    get_status({remote, Name})
+  end.
+
+
+
+init([]) ->
+  {ok, {{one_for_one, 10, 3600},[
+  ]}}.

data/erlang/lib/gcd/ebin/gcd.app

@@ -0,0 +1,18 @@
+{application, gcd, [
+  {description, "Grand Central Dispatch"},
+  {vsn, "0.1"},
+  {modules, [
+    gcd_app,
+    gcd_sup,
+    gcd_srv,
+    gcd_event,
+    gcd_server,
+    gcd
+  ]},
+  {registered, [
+    gcd_srv,
+    gcd_sup
+  ]},
+  {applications, [kernel, stdlib]},
+  {mod, {gcd_app, []}}
+]}.

data/erlang/lib/gcd/include/gcd.hrl

@@ -0,0 +1,5 @@
+
+-record(state,    {local,remote,nodes,monitors}).
+-record(service,  {pid,node,location,name,description}).
+-record(node,     {name}).
+-record(monitor,  {ref,pid,pattern}).

data/erlang/lib/gcd/rebar.config

@@ -0,0 +1,3 @@
+{cover_enabled, true}.
+{erl_opts, [debug_info, fail_on_warning, {i, ".."}]}.
+{lib_dirs, [".."]}.

data/erlang/lib/gcd/src/gcd.erl

@@ -0,0 +1,51 @@
+-module(gcd).
+-include("gcd.hrl").
+
+-export([start/0, stop/0]).
+
+-export([connect/1]).
+-export([register/2, unregister/0]).
+-export([monitor/1, demonitor/1]).
+-export([match_object/1, foldl/2]).
+
+
+%%% Application API
+start() ->
+  application:start(gcd).
+
+stop() ->
+  application:stop(gcd).
+
+
+%%% External API
+connect(Node) when is_atom(Node) -> 
+  connect([Node]);
+connect([]) -> ok;
+connect([Node|Rest]) ->
+  net_adm:ping(Node),
+  connect(Rest).
+
+register(Name, Description) ->
+  Info = erlang:process_info(self()),
+  RegisteredName = proplists:get_value(registered_name, Info),
+  Location =
+  case RegisteredName of
+  undefined -> self();
+  _Else     -> {RegisteredName, node()}
+  end,
+  gen_server:call(gcd_srv, {register, self(), Name, node(), Location, Description}).
+
+unregister() ->
+  gen_server:call(gcd_srv, {unregister, self()}).
+
+monitor(Pattern) ->
+  gen_server:call(gcd_srv, {monitor, self(), Pattern}).
+
+demonitor(Ref) ->
+  gen_server:call(gcd_srv, {demonitor, Ref}).
+
+foldl(Fun, Acc) ->
+  gen_server:call(gcd_srv, {foldl, Fun, Acc}).
+
+match_object(Pattern) ->
+  gen_server:call(gcd_srv, {match_object, Pattern}).

data/erlang/lib/gcd/src/gcd_app.erl

@@ -0,0 +1,13 @@
+-module(gcd_app).
+-behaviour(application).
+
+-export([start/2, stop/1]).
+
+start(_StartType, _StartArgs) ->
+  case gcd_sup:start_link() of
+  {ok, Pid} -> {ok, Pid};
+  Error     -> Error
+  end.
+
+stop(_State) ->
+  ok.

data/erlang/lib/gcd/src/gcd_event.erl

@@ -0,0 +1,39 @@
+-module(gcd_event).
+-include("gcd.hrl").
+
+
+-export([notify/2, sync_notify/2]).
+-export([call/3, call/4]).
+
+
+notify(Pattern, Message) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_event:notify(Location, Message)
+  end ||
+  Service <- gcd:match_object(Pattern)].
+
+
+sync_notify(Pattern, Message) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_event:sync_notify(Location, Message)
+  end ||
+  Service <- gcd:match_object(Pattern)].
+
+
+call(Pattern, Handler, Message) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_event:call(Location, Handler, Message)
+  end ||
+  Service <- gcd:match_object(Pattern)].
+
+
+call(Pattern, Handler, Message, Timeout) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_event:call(Location, Handler, Message, Timeout)
+  end ||
+  Service <- gcd:match_object(Pattern)].
+

data/erlang/lib/gcd/src/gcd_server.erl

@@ -0,0 +1,30 @@
+-module(gcd_server).
+-include("gcd.hrl").
+
+
+-export([cast/2]).
+-export([call/2, call/3]).
+
+
+call(Pattern, Message) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_server:call(Location, Message)
+  end ||
+  Service <- gcd:match_object(Pattern)].
+
+
+call(Pattern, Message, Timeout) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_server:call(Location, Message, Timeout)
+  end ||
+  Service <- gcd:match_object(Pattern)].
+
+
+cast(Pattern, Message) ->
+  [begin
+    #service{location=Location} = Service,
+    gen_server:cast(Location, Message)
+  end ||
+  Service <- gcd:match_object(Pattern)].

data/erlang/lib/gcd/src/gcd_srv.erl

@@ -0,0 +1,186 @@
+-module(gcd_srv).
+-behaviour(gen_server).
+-include("gcd.hrl").
+
+-export([start_link/0]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, terminate/2, code_change/3]).
+
+-define(L(State), State#state.local).
+-define(R(State), State#state.remote).
+-define(N(State), State#state.nodes).
+-define(M(State), State#state.monitors).
+
+
+%%% Start the server
+start_link() ->
+  gen_server:start_link({local, gcd_srv}, ?MODULE, [], []).
+
+
+%%% Initialize the server
+init([]) ->
+  net_kernel:monitor_nodes(true),
+  Local    = ets:new(gcd_srv_local,    [set,private,{keypos,2}]),
+  Remote   = ets:new(gcd_srv_remote,   [set,private,{keypos,4}]),
+  Nodes    = ets:new(gcd_srv_nodes,    [set,private,{keypos,2}]),
+  Monitors = ets:new(gcd_srv_monitors, [set,private,{keypos,2}]),
+  {ok, #state{local=Local,remote=Remote,nodes=Nodes,monitors=Monitors}}.
+
+
+%%% Handle call messages
+handle_call({foldl, Fun, Acc1}, _From, State) ->
+  Acc2 = ets:foldl(Fun, Acc1, ?L(State)),
+  Acc3 = ets:foldl(Fun, Acc2, ?R(State)),
+  {reply, Acc3, State};
+
+handle_call({match_object, Pattern}, _From, State) ->
+  Services1 = ets:match_object(?L(State), Pattern),
+  Services2 = ets:match_object(?R(State), Pattern),
+  {reply, Services1 ++ Services2, State};
+
+handle_call({register, Pid, Name, Node, Location, Description}, _From, State) ->
+  Service = #service{node=Node, location=Location, pid=Pid, name=Name, description=Description},
+  case ets:insert_new(?L(State), Service) of
+  true ->
+    erlang:monitor(process, Pid),
+    gen_server:cast(self(), {serviceup, Service}),
+    {reply, ok, State};
+  false ->
+    {reply, {error, already_registerd}, State}
+  end;
+
+handle_call({unregister, Pid}, _From, State) ->
+  case ets:lookup(?L(State), Pid) of
+  [Service] ->
+    gen_server:cast(self(), {servicedown, Service}),
+    ets:delete(?L(State), Pid);
+  _ -> ok
+  end,
+  {reply, ok, State};
+
+handle_call({monitor, Pid, Pattern}, _From, State) ->
+  Monitor = #monitor{ref=erlang:make_ref(), pid=Pid, pattern=Pattern},
+  case ets:insert_new(?M(State), Monitor) of
+  true ->
+    erlang:monitor(process, Pid),
+    {reply, Monitor#monitor.ref, State};
+  false ->
+    {reply, {error, already_registerd}, State}
+  end;
+
+handle_call({demonitor, Ref}, _From, State) ->
+  ets:delete(?M(State), Ref),
+  {reply, ok, State};
+
+handle_call(_Request, _From, State) ->
+  {reply, ok, State}.
+
+
+%%% Handle cast messages
+handle_cast({info, Node, Nodes, Services}, State) ->
+  ets:insert(?N(State), #node{name=Node}),
+  ets:insert(?R(State), Services),
+  [net_adm:ping(Node1) || Node1 <- Nodes],
+  [gen_server:cast(self(), {serviceup, Service}) || Service <- Services],
+  {noreply, State};
+
+handle_cast({serviceup, Service}, State) ->
+  case Service#service.pid of
+  remote ->
+    ets:insert(?R(State), Service);
+  _Pid   -> 
+    ets:insert(?L(State), Service),
+    ets:foldl(fun(#node{name=Node}, _) ->
+      gen_server:cast({gcd_srv, Node}, {serviceup, Service#service{pid=remote}})
+    end, [], ?N(State))
+  end,
+  
+  ets:foldl(fun(#monitor{pattern=Pattern,pid=Pid,ref=Ref}, _) ->
+    case ets:test_ms(Service, [{Pattern,[],[true]}]) of
+    {ok, true} ->
+      Pid ! {serviceup, Ref, Service};
+    _Else -> ignore
+    end
+  end, [], ?M(State)),
+  
+  {noreply, State};
+
+handle_cast({servicedown, Service}, State) ->
+  case Service#service.pid of
+  remote ->
+    ets:delete(?R(State), Service#service.location);
+  _Pid   ->
+    ets:delete(?L(State), Service#service.pid),
+    ets:foldl(fun(#node{name=Node}, _) ->
+      gen_server:cast({gcd_srv, Node}, {servicedown, Service#service{pid=remote}})
+    end, [], ?N(State))
+  end,
+  
+  ets:foldl(fun(#monitor{pattern=Pattern,pid=Pid,ref=Ref}, _) ->
+    case ets:test_ms(Service, [{Pattern,[],[true]}]) of
+    {ok, true} ->
+      Pid ! {servicedown, Ref, Service};
+    _Else -> ignore
+    end
+  end, [], ?M(State)),
+  
+  {noreply, State};
+
+handle_cast(stop, State) ->
+  {stop, normal, State};
+
+handle_cast(_Msg, State) ->
+  {noreply, State}.
+
+
+%%% Handle generic messages
+handle_info({'DOWN', _Ref, process, Pid, _Reason}, State) ->
+  case ets:lookup(?L(State), Pid) of
+  [Service] ->
+    gen_server:cast(self(), {servicedown, Service}),
+    ets:delete(?L(State), Pid);
+  _ -> ok
+  end,
+  Monitors = ets:foldl(fun
+  (#monitor{ref=Ref,pid=Pid1}, Acc) when Pid1 == Pid ->
+    [Ref|Acc];
+  (_Else, Acc) -> Acc
+  end, [], ?M(State)),
+  [ets:delete(?M(State), Ref) || Ref <- Monitors],
+  {noreply, State};
+
+handle_info({nodeup, Node}, State) ->
+  gen_server:cast({gcd_srv, Node}, {info, node(),
+    ets:foldl(fun(#node{name=N}, Acc) -> [N|Acc]                     end, [], ?N(State)),
+    ets:foldl(fun(#service{}=S, Acc)  -> [S#service{pid=remote}|Acc] end, [], ?L(State))
+  }),
+  
+  {noreply, State};
+
+handle_info({nodedown, Node}, State) ->
+  ets:delete(?N(State), Node),
+  
+  Keys = ets:foldl(fun
+  (#service{node=Node1,location=L}=Service, Acc) when Node1 == Node->
+    gen_server:cast(self(), {servicedown, Service}),
+    [L|Acc];
+  (_Else, Acc) -> Acc
+  end, [], ?R(State)),
+  [ets:delete(?R(State), Key) || Key <- Keys],
+  
+  {noreply, State};
+
+handle_info(_Info, State) ->
+  {noreply, State}.
+
+%%% Before stopping the server
+terminate(_Reason, State) ->
+  ets:delete(?L(State)),
+  ets:delete(?R(State)),
+  ets:delete(?N(State)),
+  ets:delete(?M(State)),
+  ok.
+
+%%% Code Changes
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.