capricorn 0.2.25 → 2.0.0

data/erlang/lib/capricorn/src/capricorn.erl

@@ -0,0 +1,45 @@
+%%
+%% Start application module
+%%
+%% File   : capricorn.erl
+%% Created: 2010-01-04
+%%
+%% @author simonmenke <simon.menke@gmail.com>
+%% @copyright 2010 simonmenke
+%%
+%% @doc TODO make nice description
+%%
+
+-module(capricorn).
+-author('simonmenke <simon.menke@gmail.com>').
+-include("capricorn.hrl").
+
+-export([start/0, stop/0, restart/0, reload/0]).
+
+%% @spec start() -> ok
+%% @doc Start the capricorn application
+start() ->
+  application:start(capricorn).
+
+%% @spec stop() -> ok
+%% @doc Stop the capricorn application
+stop() ->
+  application:stop(capricorn).
+
+restart() ->
+  case stop() of
+  ok ->
+    start();
+  {error, {not_started,capricorn}} ->
+    start();
+  {error, Reason} ->
+    {error, Reason}
+  end.
+
+reload() ->
+  case supervisor:terminate_child(cap_sup, cap_config) of
+  ok ->
+    supervisor:restart_child(cap_sup, cap_config);
+  {error, Reason} ->
+    {error, Reason}
+  end.

data/erlang/lib/capricorn/src/capricorn_app.erl

@@ -0,0 +1,36 @@
+%%
+%% Application module
+%%
+%% File   : capricorn_app.erl
+%% Created: 2010-01-04
+%%
+%% @author simonmenke <simon.menke@gmail.com>
+%% @copyright 2010 simonmenke
+%%
+%% @doc TODO make nice description
+%%
+
+-module(capricorn_app).
+-author('simonmenke <simon.menke@gmail.com>').
+-include("capricorn.hrl").
+
+-behaviour(application).
+ 
+-export([start/2, stop/1]).
+
+-spec start(_,_) -> {'error','already_started'} | {'ok',pid()} .
+start(_Type, _) ->
+  NodeType = get_ini_node_type(),
+  cap_sup:start_link(NodeType).
+
+stop(_) ->
+  cap_sup:stop(),
+  ok.
+
+-spec get_ini_node_type() -> machine | cluster .
+get_ini_node_type() ->
+  case init:get_argument(node_type) of
+  error          -> machine;
+  {ok, [[]]}     -> machine;
+  {ok, [[Type]]} -> list_to_atom(Type)
+  end.

data/erlang/lib/emq/ebin/emq.app

@@ -0,0 +1,17 @@
+{application, emq, [
+  {description, "Erlang Message Queue"},
+  {vsn, "0.1.0"},
+  {modules, [
+    emq,
+    emq_app,
+    emq_sup,
+    emq_pool,
+    emq_queue,
+    emq_status
+  ]},
+  {registered,[
+    emq_sup
+  ]},
+  {applications, [kernel, stdlib]},
+  {mod, {emq_app, []}}
+]}.

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

@@ -0,0 +1,261 @@
+-module(emq).
+-behaviour(gen_server).
+
+
+
+-export([new/2]).
+-export([push/3, push/4, push/5, push/6]).
+-export([size/1, jobs/1, status/2, status/3]).
+
+-export([start_link/1]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, terminate/2, code_change/3]).
+
+-export([test/0]).
+
+
+
+-record(state, {
+  name   :: atom(),
+  queue  :: pid(),
+  pool   :: pid(),
+  status :: pid()
+}).
+% -type state() :: #state{} .
+
+
+
+%%% External API
+new(Name, Options) ->
+  emq_sup:start_queue(Name, Options).
+
+
+
+push(QueueName, Id, Fun) ->
+  push(QueueName, Id, [], Fun).
+
+push(QueueName, Id, Dependencies, Fun) ->
+  push(QueueName, Id, Dependencies, [], Fun).
+
+push(QueueName, Id, Dependencies, Dependents, Fun) ->
+  push(QueueName, Id, Dependencies, Dependents, [], Fun).
+
+push(QueueName, Id, Dependencies, Dependents, Callbacks, Fun) ->
+  {ok, Pid} = emq_sup:get_emq(QueueName),
+  gen_server:cast(Pid, {push, Id, Dependencies, Dependents, Callbacks, Fun}),
+  {ok, {QueueName, Id}}.
+
+
+
+size(QueueName) ->
+  {ok, Pid} = emq_sup:get_queue(QueueName),
+  emq_queue:size(Pid).
+
+
+
+jobs(QueueName) ->
+  {ok, Pid} = emq_sup:get_status(QueueName),
+  emq_status:get_all(Pid).
+
+
+
+status(QueueName, Id) ->
+  {ok, Pid} = emq_sup:get_emq(QueueName),
+  gen_server:call(Pid, {status, Id}).
+
+status(QueueName, Id, Status) ->
+  {ok, Pid} = emq_sup:get_emq(QueueName),
+  gen_server:cast(Pid, {status, Id, Status}).
+
+
+
+%%% Start the server
+-spec start_link([{size, pos_integer()}]) -> {ok, pid()} .
+start_link(Options) ->
+  gen_server:start_link(?MODULE, Options, []).
+
+
+
+%%% Initialize the server
+init(Options) ->
+  Name     = proplists:get_value(name, Options),
+  PoolSize = proplists:get_value(size, Options, 3),
+  {ok, Pool}   = emq_pool:start_link(Name, PoolSize),
+  {ok, Queue}  = emq_queue:start_link(Name),
+  {ok, Status} = emq_status:start_link(Name),
+  
+  emq_sup:setup_process(Pool ,  Name, self(), Queue, Pool, Status),
+  emq_sup:setup_process(Queue,  Name, self(), Queue, Pool, Status),
+  emq_sup:setup_process(Status, Name, self(), Queue, Pool, Status),
+  
+  erlang:put('$emq_name',   Name),
+  erlang:put('$emq',        self()),
+  erlang:put('$emq_pool',   Pool),
+  erlang:put('$emq_queue',  Queue),
+  erlang:put('$emq_status', Status),
+  
+  {ok, #state{ pool = Pool, queue = Queue, status = Status, name = Name }}.
+
+
+
+%%% Handle call messages
+handle_call({'$emq_internal_info'}, _From, State) ->
+  {reply, {ok, {
+    erlang:get('$emq_name'),
+    erlang:get('$emq_pool'),
+    erlang:get('$emq_queue'),
+    erlang:get('$emq_status')
+  }}, State};
+
+handle_call({status, Id}, _From, State) ->
+  #state { status = Status } = State,
+  {reply, emq_status:get(Status, Id), State}.
+
+
+
+%%% Handle cast messages
+handle_cast({push, Id, Dependencies, Dependents, Callbacks, Fun}, State) ->
+  #state { queue = Queue } = State,
+  emq_queue:push(Queue, Id, Dependencies, Dependents, Callbacks, Fun),
+  do_try_exec(State),
+  {noreply, State};
+
+handle_cast({status, Id, StatusObject}, State) ->
+  #state { status = Status } = State,
+  emq_status:put(Status, Id, StatusObject),
+  {noreply, State}.
+
+
+
+%%% Handle generic messages
+handle_info(kick, State) ->
+  do_try_exec(State),
+  {noreply, State};
+
+handle_info({pool_did_job, Id}, State) ->
+  #state { queue = Queue } = State,
+  emq_queue:commit(Queue, Id),
+  do_try_exec(State),
+  {noreply, State}.
+
+
+
+%%% Before stopping the server
+terminate(_Reason, _State) ->
+  % stop children
+  ok.
+
+
+
+%%% Code Changes
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.
+
+
+
+%%% Internal API
+do_try_exec(State) ->
+  #state { queue = Queue, pool = Pool } = State,
+  {ok, StatusPid} = emq_sup:get_status(local),
+  case emq_queue:reserve(Queue) of
+  {value, Id, Job, Callbacks} ->
+    R = emq_pool:do(Pool, fun({Id1, Job1, Callbacks1, StatusPid1}) ->
+      try
+        emq_status:put(StatusPid1, Id1, active),
+        case Job1 of
+        {Mod, Fun, Args} -> erlang:apply(Mod, Fun, Args);
+        {Fun, Args}      -> erlang:apply(Fun, Args);
+        Fun              -> Fun()
+        end
+      of
+        Result ->
+          lists:map(fun(Callback) ->
+            Callback(done, Result)
+          end, Callbacks1)
+      catch
+        error:Reason ->
+          lists:map(fun(Callback) ->
+            Callback(error, Reason)
+          end, Callbacks1),
+          error_logger:error_report({error, Id1, Reason, erlang:get_stacktrace()});
+        throw:Reason ->
+          lists:map(fun(Callback) ->
+            Callback(throw, Reason)
+          end, Callbacks1),
+          error_logger:error_report({throw, Id1, Reason});
+        exit:Reason ->
+          lists:map(fun(Callback) ->
+            Callback(exit, Reason)
+          end, Callbacks1),
+          error_logger:error_report({exit, Id1, Reason})
+      after
+        emq_status:delete(StatusPid1, Id1)
+      end,
+      Id1
+    end, {Id, Job, Callbacks, StatusPid}),
+    case R of
+    {error, no_workers} ->
+      emq_queue:rollback(Queue, Id);
+    ok ->
+      ignore
+    end;
+  {empty} -> ignore
+  end.
+
+
+
+test() ->
+  application:start(emq),
+  
+  emq:new(hello, [{size, 1}]),
+  
+  emq:push(hello, hi, fun() ->
+    receive after 3000 -> io:format("hi ") end
+  end),
+  emq:push(hello, simon, [{hello, hi}], fun() ->
+    receive after 3000 -> io:format("simon!\n") end
+  end),
+  
+  emq:push(hello, bye, fun() ->
+    receive after 3000 -> io:format("bye ") end
+  end),
+  emq:push(hello, simon, [{hello, bye}], fun() ->
+    receive after 3000 -> io:format("simon!\n") end
+  end),
+  
+  % {ok, Id1} = emq:push(hello, make_ref(), fun() ->
+  %   receive after 3000 -> io:format("hi ") end
+  % end),
+  % emq:push(hello, make_ref(), [Id1], fun() ->
+  %   receive after 3000 -> io:format("simon!\n") end
+  % end),
+  % 
+  % {ok, Id2} = emq:push(hello, make_ref(), fun() ->
+  %   receive after 3000 -> io:format("hi ") end
+  % end),
+  % emq:push(hello, make_ref(), [Id2], fun() ->
+  %   receive after 3000 -> io:format("simon!\n") end
+  % end),
+  % 
+  % {ok, Id3} = emq:push(hello, make_ref(), fun() ->
+  %   receive after 3000 -> io:format("hi ") end
+  % end),
+  % emq:push(hello, make_ref(), [Id3], fun() ->
+  %   receive after 3000 -> io:format("simon!\n") end
+  % end),
+  % 
+  % {ok, Id4} = emq:push(hello, make_ref(), fun() ->
+  %   receive after 3000 -> io:format("hi ") end
+  % end),
+  % emq:push(hello, make_ref(), [Id4], fun() ->
+  %   receive after 3000 -> io:format("simon!\n") end
+  % end),
+  % 
+  % {ok, Id5} = emq:push(hello, make_ref(), fun() ->
+  %   receive after 3000 -> io:format("hi ") end
+  % end),
+  % emq:push(hello, make_ref(), [Id5], fun() ->
+  %   receive after 3000 -> io:format("simon!\n") end
+  % end),
+  
+  ok.

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

@@ -0,0 +1,11 @@
+-module(emq_app).
+-behaviour(application).
+ 
+-export([start/2, stop/1]).
+
+start(_Type, _Args) ->
+  emq_sup:start_link().
+
+stop(_) ->
+  emq_sup:stop(),
+  ok.

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

@@ -0,0 +1,178 @@
+-module(emq_pool).
+-behaviour(gen_server).
+
+
+
+-export([size/1, size/2, active/1, idle/1, do/3]).
+
+-export([start_link/2]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, terminate/2, code_change/3]).
+
+-export([do_init_worker/2]).
+
+
+
+-record(state, {
+  name    :: atom(),
+  workers :: [pid()],
+  waiters :: [pid()],
+  size    :: pos_integer(),
+  owner   :: pid()
+}).
+-type state() :: #state{} .
+
+
+
+%%% External API
+size(Pid) ->
+  gen_server:call(Pid, {size}).
+
+
+
+size(Pid, Size) ->
+  gen_server:call(Pid, {size, Size}).
+
+
+
+active(Pid) ->
+  gen_server:call(Pid, {active}).
+
+
+
+idle(Pid) ->
+  gen_server:call(Pid, {idle}).
+
+
+
+do(Pid, Fun, Ctx) ->
+  gen_server:call(Pid, {do, Fun, Ctx}).
+
+
+
+%%% Start the server
+-spec start_link(atom(), pos_integer()) -> {ok, pid()} .
+start_link(Name, Size) ->
+  gen_server:start_link(?MODULE, {Name, Size, self()}, []).
+
+
+
+%%% Initialize the server
+-spec init({atom(), pos_integer(), pid()}) -> {ok, state()} .
+init({Name, Size, Owner}) ->
+  {ok, #state{ waiters=[], workers=[], size=Size, owner=Owner, name=Name }}.
+
+
+
+%%% Handle call messages
+handle_call({setup_process, Name, Emq, Queue, Pool, Status}, _From, State) ->
+  erlang:put('$emq_name',   Name),
+  erlang:put('$emq',        Emq),
+  erlang:put('$emq_pool',   Pool),
+  erlang:put('$emq_queue',  Queue),
+  erlang:put('$emq_status', Status),
+  {reply, ok, State};
+
+handle_call({size, Size}, _From, State) ->
+  {reply, ok, State#state{ size=Size }};
+
+handle_call({size}, _From, State) ->
+  {reply, State#state.size, State};
+
+handle_call({active}, _From, State) ->
+  {reply, erlang:length(State#state.workers), State};
+
+handle_call({idle}, _From, State) ->
+  {reply, erlang:length(State#state.waiters), State};
+
+handle_call({do, Fun, Ctx}, _From, State) ->
+  case do_get_worker(State) of
+  {State1, Worker} ->
+    Worker ! {exec, Fun, Ctx},
+    {reply, ok, State1};
+  {State1} ->
+    {reply, {error, no_workers}, State1}
+  end.
+
+
+
+%%% Handle cast messages
+handle_cast(_Msg, State) ->
+  {noreply, State}.
+
+
+%%% Handle generic messages
+handle_info({done, Worker, Ctx}, State) ->
+  #state { waiters = Waiters, workers = Workers, owner = Owner } = State,
+  Owner ! {pool_did_job, Ctx},
+  {noreply, State#state{
+    waiters = [Worker|Waiters],
+    workers = lists:delete(Worker, Workers)
+  }};
+
+handle_info({'DOWN', _, process, Worker, Reason}, State) ->
+  error_logger:error_msg("Worker Exited unexpectedly~n", []),
+  error_logger:error_report(Reason),
+  #state { waiters = Waiters, workers = Workers } = State,
+  {noreply, State#state{
+    waiters = lists:delete(Worker, Waiters),
+    workers = lists:delete(Worker, Workers)
+  }}.
+
+
+%%% Before stopping the server
+terminate(_Reason, _State) ->
+  ok.
+
+
+%%% Code Changes
+code_change(_OldVsn, State, _Extra) ->
+  [Pid1 ! stop || Pid1 <- State#state.workers],
+  [Pid2 ! stop || Pid2 <- State#state.waiters],
+  {ok, State}.
+
+
+%%% Internal API
+-spec do_get_worker(state()) -> {state(), pid()} | {state()} .
+do_get_worker(State) ->
+  #state { size = Size, workers = Workers, waiters = Waiters, owner = Owner } = State,
+  if
+  length(Waiters) > 0 ->
+    [Pid | Waiters2] = Waiters,
+    Workers2 = [Pid | Workers],
+    {State#state { workers=Workers2, waiters=Waiters2 }, Pid};
+  length(Workers) < Size ->
+    Pid = spawn(?MODULE, do_init_worker, [self(), Owner]),
+    erlang:monitor(process, Pid),
+    Pid ! go,
+    {State#state { workers=[Pid | Workers] }, Pid};
+  true ->
+    {State}
+  end.
+
+do_init_worker(Pool, Owner) ->
+  erlang:monitor(process, Pool),
+  receive
+  go ->
+    do_loop_worker(Pool, Owner);
+  stop ->
+    erlang:exit(normal);
+  {'DOWN', _, process, Pool, _} ->
+    erlang:exit(normal)
+  after 300000 ->
+    erlang:exit(normal)
+  end.
+
+do_loop_worker(Pool, Owner) ->
+  receive
+  stop ->
+    erlang:exit(normal);
+  {'DOWN', _, process, Pool, _} ->
+    erlang:exit(normal);
+  {exec, Fun, Ctx1} ->
+    Ctx2 = erlang:apply(Fun, [Ctx1]),
+    Pool ! {done, self(), Ctx2},
+    do_loop_worker(Pool, Owner)
+  after 300000 ->
+    erlang:exit(normal)
+  end.