capricorn 0.2.25 → 2.0.0

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

@@ -0,0 +1,25 @@
+-module(cap_config).
+-include("capricorn.hrl").
+
+
+
+-export([all/0, get/1, get/2, get/3]).
+
+
+
+all() ->
+  application:get_all_env(capricorn) ++ init:get_arguments().
+
+
+
+get(Section) ->
+  proplists:get_value(Section, cap_config:all(), []).
+
+get(Section, Key) ->
+  cap_config:get(Section, Key, undefined).
+
+get(Section, Key, Default) ->
+  SectionValues = cap_config:get(Section),
+  proplists:get_value(Key, SectionValues, Default).
+
+

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

@@ -0,0 +1,26 @@
+-module(cap_dets_updater).
+
+-export([update/2]).
+
+update(Table, Fun) ->
+  NewTerms = dets:foldl(fun(Term, Acc) ->
+    update_members([Term], Fun, Acc)
+  end, [], Table),
+  dets:delete_all_objects(Table),
+  dets:insert(Table, NewTerms),
+  ok.
+
+update_members([], _Fun, Acc) -> Acc;
+update_members([OldTerm|Rest], Fun, Acc) ->
+  case Fun(OldTerm) of
+  ok ->
+    update_members(Rest, Fun, [OldTerm|Acc]);
+  remove ->
+    update_members(Rest, Fun, Acc);
+  {update, Terms} when is_list(Terms) ->
+    update_members(Terms++Rest, Fun, Acc);
+  {update, Term} when is_tuple(Term) ->
+    update_members([Term|Rest], Fun, Acc);
+  Else ->
+    erlang:error({badarg, Else})
+  end.

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

@@ -0,0 +1,35 @@
+-module(cap_event_sup).
+-behaviour(gen_server).
+
+-include("capricorn.hrl").
+
+-export([start_link/3,start_link/4, stop/1]).
+-export([init/1, terminate/2, handle_call/3, handle_cast/2, handle_info/2,code_change/3]).
+
+start_link(EventMgr, EventHandler, Args) ->
+  gen_server:start_link(cap_event_sup, {EventMgr, EventHandler, Args}, []).
+
+start_link(ServerName, EventMgr, EventHandler, Args) ->
+  gen_server:start_link(ServerName, cap_event_sup, {EventMgr, EventHandler, Args}, []).
+
+stop(Pid) ->
+  gen_server:cast(Pid, stop).
+
+init({EventMgr, EventHandler, Args}) ->
+  ok = gen_event:add_sup_handler(EventMgr, EventHandler, Args),
+  {ok, {EventMgr, EventHandler}}.
+
+terminate(_Reason, _State) ->
+  ok.
+
+handle_call(_Whatever, _From, State) ->
+  {ok, State}.
+
+handle_cast(stop, State) ->
+  {stop, normal, State}.
+
+handle_info({gen_event_EXIT, _Handler, Reason}, State) ->
+  {stop, Reason, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.

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

@@ -0,0 +1,24 @@
+-module(cap_events).
+
+
+-export([start_link/0]).
+-export([notify/1, notify/2]).
+
+
+start_link() ->
+  gen_event:start_link({local, ?MODULE}).
+
+
+notify(Msg) ->
+  gen_event:notify(?MODULE, Msg).
+
+
+notify(Node, Msg) when is_atom(Node) ->
+  notify([Node], Msg);
+  
+notify([Node|Rest], Msg) ->
+  gen_event:notify({?MODULE, Node}, Msg),
+  notify(Rest, Msg);
+  
+notify([], _Msg) ->
+  ok.

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

@@ -0,0 +1,87 @@
+-module(cap_external_api).
+-behaviour(bertrpc).
+
+
+
+-export([start_link/1]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, terminate/2, code_change/3]).
+
+
+
+-record(state, {
+  user     :: binary() | undefined,
+  services :: [atom()]
+}).
+-type state() :: #state{} .
+
+
+
+-spec start_link([{atom(), atom()}]) -> {ok, pid()} .
+
+start_link(Services) ->
+  bertrpc:listen_link({local, ?MODULE}, ?MODULE, Services, 3457).
+
+
+
+-spec init([{atom(), atom()}]) -> {ok, state()} .
+
+init(Services) ->
+  {ok, #state{ services = Services }}.
+
+
+
+handle_call({machines, F, A, I}, From, State) ->
+  cap_external_machines_api:handle_call({F, A, I}, From, State);
+
+handle_call({gems, F, A, I}, From, State) ->
+  cap_external_gems_api:handle_call({F, A, I}, From, State);
+
+handle_call({applications, F, A, I}, From, State) ->
+  cap_external_apps_api:handle_call({F, A, I}, From, State);
+
+handle_call({M, F, A, I}, From, State) ->
+  #state { services = Services } = State,
+  case proplists:get_value(M, Services) of
+  undefined ->
+    {reply, {error, service_not_found}, State};
+  Module ->
+    Module:handle_call({F, A, I}, From, State)
+  end.
+
+
+
+handle_cast({machines, F, A, I}, State) ->
+  cap_external_machines_api:handle_cast({F, A, I}, State);
+
+handle_cast({gems, F, A, I}, State) ->
+  cap_external_gems_api:handle_cast({F, A, I}, State);
+
+handle_cast({applications, F, A, I}, State) ->
+  cap_external_apps_api:handle_cast({F, A, I}, State);
+
+handle_cast({M, F, A, I}, State) ->
+  #state { services = Services } = State,
+  case proplists:get_value(M, Services) of
+  undefined ->
+    {noreply, State};
+  Module ->
+    Module:handle_cast({F, A, I}, State)
+  end.
+
+
+
+handle_info(_Info, State) ->
+  {noreply, State}.
+
+
+
+terminate(_Reason, _State) ->
+  ok.
+
+
+
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.
+
+

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

@@ -0,0 +1,125 @@
+-module(cap_external_apps_api).
+-export([handle_call/3, handle_cast/2]).
+
+
+
+handle_call({all,
+            [Node], _},
+            _From, State) ->
+  try
+    All = cap_machine_apps:all(Node),
+    {reply, {ok, All}, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({create,
+            [Node, Name, Domains, Env], _},
+            _From, State) ->
+  try
+    ok = cap_machine_apps:create(Node, Name, Domains, Env, [<<"my_gem">>]),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({import,
+            [Node, Name, Domains, Env, Root, Gems, Uid, Gid], _},
+            _From, State) ->
+  try
+    ok = cap_machine_apps:import(Node,
+                                 Name,
+                                 Domains,
+                                 Env,
+                                 Gems,
+                                 Root,
+                                 Uid,
+                                 Gid),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({restart,
+            [Node, Id], _},
+            _From, State) ->
+  try
+    ok = cap_application:restart({Node, Id}),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({start,
+            [Node, Id], _},
+            _From, State) ->
+  try
+    ok = cap_application:start({Node, Id}),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({stop,
+            [Node, Id], _},
+            _From, State) ->
+  try
+    ok = cap_application:stop({Node, Id}),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({relink,
+            [Node, Id], _},
+            _From, State) ->
+  try
+    ok = cap_application:relink({Node, Id}),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({update,
+            [Node, Id, NewDomains, NewGems], _},
+            _From, State) ->
+  try
+    ok = cap_machine_apps:update(Node, Id, NewDomains, NewGems),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({fupdate,
+            [Node, Id], _},
+            _From, State) ->
+  try
+    ok = cap_machine_apps:fupdate(Node, Id),
+    {reply, true, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end.
+
+
+
+handle_cast({_, _, _},
+            State) ->
+  {noreply, State}.
+
+

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

@@ -0,0 +1,85 @@
+-module(cap_external_gems_api).
+-export([handle_call/3, handle_cast/2]).
+
+
+
+handle_call({push,
+            _, Info},
+            _From, State) ->
+  case proplists:get_value(stream, Info) of
+  undefined ->
+    Reason = {user, 1, <<"CapricornGemError">>,
+                       <<"This is not a gem">>, []},
+    {reply, {error, Reason}, State};
+  
+  _WeHaveAStream ->
+    try
+      {ok, Data} = collect_stream_data(sof, []),
+      cap_cluster_gems:push(Data)
+    of
+    {ok,Missing} ->
+      {reply, {ok,Missing}, State};
+      
+    {error,already_present} ->
+      Reason = {user, 1, <<"CapricornGemError">>,
+                         <<"This gem is already present in the cluster.">>, []},
+      {reply, {error, Reason}, State};
+      
+    {error,{[gem_error,ErrorMessage]}} ->
+      Reason = {user, 1, <<"CapricornGemError">>, ErrorMessage, []},
+      {reply, {error, Reason}, State};
+      
+    {error,{[not_found]}} ->
+      Reason = {user, 1, <<"CapricornGemError">>,
+                         <<"Transfering failed!">>, []},
+      {reply, {error, Reason}, State}
+      
+    catch
+      throw:T -> {reply, {error, T}, State}
+    end
+  end;
+
+
+
+handle_call({all,
+            _, _},
+            _From, State) ->
+  try
+    {ok, All} = cap_cluster_gems:all(),
+    {reply, {ok, All}, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end;
+
+
+
+handle_call({missing,
+            _, _},
+            _From, State) ->
+  try
+    {ok, Missing} = cap_cluster_gems:missing(),
+    {reply, {ok, Missing}, State}
+  catch
+    throw:T -> {reply, {error, T}, State}
+  end.
+
+
+
+handle_cast(_, State) ->
+  {noreply, State}.
+
+
+
+collect_stream_data(sof, Acc) ->
+  collect_stream_data(bertrpc:stream(), Acc);
+
+collect_stream_data({ok, eof}, Acc) ->
+  {ok, list_to_binary(lists:reverse(Acc))};
+
+collect_stream_data({error, Reason}, _) ->
+  {error, Reason};
+
+collect_stream_data({ok, Data}, Acc) ->
+  collect_stream_data(bertrpc:stream(), [Data|Acc]).
+
+

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

@@ -0,0 +1,18 @@
+-module(cap_external_machines_api).
+-export([handle_call/3, handle_cast/2]).
+
+
+
+handle_call({all,
+            _, _},
+            _From, State) ->
+  Nodes    = [atom_to_list(Node) || Node <- nodes()],
+  Machines = [list_to_atom(Node) || Node <- Nodes, string:substr(Node, 1, 8) == "machine-"],
+  {reply, Machines, State}.
+
+
+
+handle_cast(_, State) ->
+  {noreply, State}.
+
+

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

@@ -0,0 +1,111 @@
+-module(cap_gem_utils).
+-include("capricorn.hrl").
+
+
+-export([match_requirements/2, find_matches/2, match_requirement/2]).
+
+
+%%% External API
+find_matches(Versions, Requirements) ->
+  find_matches(Versions, Requirements, []).
+
+find_matches([], _Requirements, Acc) ->
+  Acc;
+
+find_matches([Version|Other], Requirements, Acc) ->
+  case match_requirements(Version, Requirements) of
+  true  -> find_matches(Other, Requirements, [Version|Acc]);
+  false -> find_matches(Other, Requirements, Acc)
+  end.
+
+
+match_requirements(_, []) ->
+  true;
+
+match_requirements(Version, [Req|Rest]) ->
+  case match_requirement(Version, Req) of
+  true  -> match_requirements(Version, Rest);
+  false -> false
+  end.
+
+
+%%% Internal API
+-spec balance_versions(version(), version()) -> {version(), version()}.
+balance_versions({A},{B}) ->
+  if
+  length(A) > length(B) ->
+    case lists:nth(length(B)+1, A) of
+    E when is_list(E) ->
+      balance_versions({A}, {B++[[255]]});
+    _ ->
+      balance_versions({A}, {B++[0]})
+    end;
+  length(A) < length(B) -> 
+    case lists:nth(length(A)+1, B) of
+    E when is_list(E) ->
+      balance_versions({A++[[255]]}, {B});
+    _ ->
+      balance_versions({A++[0]}, {B})
+    end;
+  length(A) == length(B) ->
+    {{A},{B}};
+  true ->
+    {{A},{B}}
+  end.
+
+
+-spec release_version(version()) -> version().
+release_version({Parts}) ->
+  {release_version(Parts, [])}.
+
+-spec release_version(version_parts(), list()) -> version_parts().
+release_version([], Acc) ->
+  lists:reverse(Acc);
+release_version([Part|_], Acc) when is_list(Part) ->
+  lists:reverse(Acc);
+release_version([Part|Rest], Acc) when is_integer(Part) ->
+  release_version(Rest, [Part|Acc]).
+
+
+-spec bump_version(version()) -> version().
+bump_version(Version) ->
+  {Parts1} = release_version(Version),
+  Parts2 = if
+    length(Parts1) > 1 ->
+      lists:sublist(Parts1, length(Parts1)-1);
+    true -> Parts1
+  end,
+  [Last|Rest] = lists:reverse(Parts2),
+  Parts3 = lists:reverse([Last+1|Rest]),
+  {Parts3}.
+
+-spec match_requirement(version(), requirement()) -> boolean().
+match_requirement(Version, {'=', RVersion}) ->
+  {Version1, RVersion1} = balance_versions(Version, RVersion),
+  Version1 == RVersion1;
+
+match_requirement(Version, {'!=', RVersion}) ->
+  {Version1, RVersion1} = balance_versions(Version, RVersion),
+  Version1 /= RVersion1;
+
+match_requirement(Version, {'<', RVersion}) ->
+  {Version1, RVersion1} = balance_versions(Version, RVersion),
+  Version1 < RVersion1;
+
+match_requirement(Version, {'>', RVersion}) ->
+  {Version1, RVersion1} = balance_versions(Version, RVersion),
+  Version1 > RVersion1;
+
+match_requirement(Version, {'>=', RVersion}) ->
+  {Version1, RVersion1} = balance_versions(Version, RVersion),
+  Version1 >= RVersion1;
+
+match_requirement(Version, {'<=', RVersion}) ->
+  {Version1, RVersion1} = balance_versions(Version, RVersion),
+  Version1 =< RVersion1;
+
+match_requirement(Version, {'~>', RVersion}) ->
+  Version1  = release_version(Version),
+  RVersion1 = bump_version(RVersion),
+  match_requirement(Version1, {'>=', RVersion}) and 
+  match_requirement(Version1, {'<',  RVersion1}).