overlay support

This includes support for overlays and fairly complete tests

1 files changed, 324 insertions, 0 deletions

diff --git a/src/rcl_prv_overlay.erl b/src/rcl_prv_overlay.erl
new file mode 100644
index 0000000..af914ee
--- /dev/null
+++ b/src/rcl_prv_overlay.erl
@@ -0,0 +1,324 @@
+%% -*- mode: Erlang; fill-column: 80; comment-column: 75; -*-
+%%% Copyright 2012 Erlware, LLC. All Rights Reserved.
+%%%
+%%% This file is provided to you under the Apache License,
+%%% Version 2.0 (the "License"); you may not use this file
+%%% except in compliance with the License.  You may obtain
+%%% a copy of the License at
+%%%
+%%%   http://www.apache.org/licenses/LICENSE-2.0
+%%%
+%%% Unless required by applicable law or agreed to in writing,
+%%% software distributed under the License is distributed on an
+%%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+%%% KIND, either express or implied.  See the License for the
+%%% specific language governing permissions and limitations
+%%% under the License.
+%%%---------------------------------------------------------------------------
+%%% @author Eric Merritt <[email protected]>
+%%% @copyright (C) 2012 Erlware, LLC.
+%%%
+%%% @doc Given a complete built release this provider assembles that release
+%%% into a release directory.
+-module(rcl_prv_overlay).
+
+-behaviour(rcl_provider).
+
+-export([init/1,
+         do/1,
+         format_error/1]).
+
+-include_lib("relcool/include/relcool.hrl").
+
+%%============================================================================
+%% API
+%%============================================================================
+-spec init(rcl_state:t()) -> {ok, rcl_state:t()}.
+init(State) ->
+    {ok, State}.
+
+%% @doc recursively dig down into the library directories specified in the state
+%% looking for OTP Applications
+-spec do(rcl_state:t()) -> {ok, rcl_state:t()} | relcool:error().
+do(State) ->
+    {RelName, RelVsn} = rcl_state:default_release(State),
+    Release = rcl_state:get_release(State, RelName, RelVsn),
+    case rcl_release:realized(Release) of
+        true ->
+            generate_overlay_vars(State, Release);
+        false ->
+            ?RCL_ERROR({unresolved_release, RelName, RelVsn})
+    end.
+
+-spec format_error(ErrorDetail::term()) -> iolist().
+format_error({unresolved_release, RelName, RelVsn}) ->
+    io_lib:format("The release has not been resolved ~p-~s", [RelName, RelVsn]);
+format_error({ec_file_error, AppDir, TargetDir, E}) ->
+    io_lib:format("Unable to copy OTP App from ~s to ~s due to ~p",
+                  [AppDir, TargetDir, E]);
+format_error({unable_to_read_varsfile, FileName, Reason}) ->
+    io_lib:format("Unable to read vars file (~s) for overlay due to: ~p",
+                  [FileName, Reason]);
+format_error({overlay_failed, Errors}) ->
+    [[format_error(rcl_util:error_reason(Error)), "\n"] || Error <- Errors];
+format_error({dir_render_failed, Dir, Error}) ->
+    io_lib:format("rendering mkdir path failed ~s with ~p",
+                  [Dir, Error]);
+format_error({unable_to_make_symlink, AppDir, TargetDir, Reason}) ->
+    io_lib:format("Unable to symlink directory ~s to ~s because \n~s~s",
+                  [AppDir, TargetDir, rcl_util:indent(1),
+                   file:format_error(Reason)]);
+format_error({copy_failed, FromFile, ToFile, Err}) ->
+    io_lib:format("Unable to copy from ~s to ~s because of ~p",
+                  [FromFile, ToFile, Err]);
+format_error({unable_to_write, ToFile, Reason}) ->
+    io_lib:format("Unable to write to ~s because ~p",
+                  [ToFile, Reason]);
+format_error({unable_to_enclosing_dir, ToFile, Reason}) ->
+    io_lib:format("Unable to create enclosing directory for ~s because ~p",
+                  [ToFile, Reason]);
+format_error({unable_to_render_template, FromFile, Reason}) ->
+    io_lib:format("Unable to render template ~s because ~p",
+                  [FromFile, Reason]);
+format_error({unable_to_compile_template, FromFile, Reason}) ->
+    io_lib:format("Unable to compile template ~s because ~p",
+                  [FromFile, Reason]);
+format_error({unable_to_make_dir, Absolute, Error}) ->
+    io_lib:format("Unable to make directory ~s because ~p",
+                  [Absolute, Error]).
+
+%%%===================================================================
+%%% Internal Functions
+%%%===================================================================
+-spec generate_overlay_vars(rcl_state:t(), rcl_release:t()) ->
+                                   {ok, rcl_state:t()} | relcool:error().
+generate_overlay_vars(State, Release) ->
+    StateVars = generate_state_vars(State),
+    ReleaseVars = generate_release_vars(Release),
+    get_overlay_vars_from_file(State, StateVars ++ ReleaseVars).
+
+-spec get_overlay_vars_from_file(rcl_state:t(), proplists:proplist()) ->
+                                        {ok, rcl_state:t()} | relcool:error().
+get_overlay_vars_from_file(State, OverlayVars) ->
+    case rcl_state:get(State, overlay_vars, undefined) of
+        undefined ->
+            do_overlay(State, OverlayVars);
+        FileName ->
+            read_overlay_vars(State, OverlayVars, FileName)
+    end.
+
+-spec read_overlay_vars(rcl_state:t(), proplists:proplist(), file:name()) ->
+                                   {ok, rcl_state:t()} | relcool:error().
+read_overlay_vars(State, OverlayVars, FileName) ->
+    case file:consult(FileName) of
+        {ok, Terms} ->
+            do_overlay(State, OverlayVars ++ Terms);
+        {error, Reason} ->
+            ?RCL_ERROR({unable_to_read_varsfile, FileName, Reason})
+    end.
+
+-spec generate_release_vars(rcl_release:t()) -> proplists:proplist().
+generate_release_vars(Release) ->
+    [{erts_vsn, rcl_release:erts(Release)},
+     {release_erts_version, rcl_release:erts(Release)},
+     {release_name, rcl_release:name(Release)},
+     {rel_vsn, rcl_release:vsn(Release)},
+     {release_version, rcl_release:vsn(Release)},
+     {release_applications, lists:map(fun(App) ->
+                                              rcl_app_info:name(App)
+                                        end, rcl_release:application_details(Release))},
+    {release, [generate_app_vars(App)|| App <- rcl_release:application_details(Release)]},
+     {release_goals,   [if
+                            erlang:is_list(Constraint) ->
+                                Constraint;
+                            true ->
+                                rcl_depsolver:format_constraint(Constraint)
+                        end || Constraint <- rcl_release:goals(Release)]}].
+
+-spec generate_app_vars(rcl_app_info:t()) -> AppInfo::tuple().
+generate_app_vars(App) ->
+    {rcl_app_info:name(App),
+     [{version, rcl_app_info:vsn_as_string(App)},
+      {dir, rcl_app_info:dir(App)},
+      {active_dependencies, rcl_app_info:active_deps(App)},
+      {library_dependencies, rcl_app_info:library_deps(App)},
+      {link, rcl_app_info:link(App)}]}.
+
+-spec generate_state_vars(rcl_state:t()) -> proplists:proplist().
+generate_state_vars(State) ->
+    [{log, rcl_log:format(rcl_state:log(State))},
+     {output_dir, rcl_state:output_dir(State)},
+     {target_dir, rcl_state:output_dir(State)},
+     {overridden, [AppName || {AppName, _} <- rcl_state:overrides(State)]},
+     {overrides, rcl_state:overrides(State)},
+     {goals, [rcl_depsolver:format_constraint(Constraint) ||
+                 Constraint <- rcl_state:goals(State)]},
+     {lib_dirs, rcl_state:lib_dirs(State)},
+     {config_files, rcl_state:config_files(State)},
+     {providers, rcl_state:providers(State)},
+     {sys_config, rcl_state:sys_config(State)},
+     {root_dir, rcl_state:root_dir(State)},
+     {default_release_name, case rcl_state:default_release(State) of
+                                {Name0, _} ->
+                                    Name0
+                            end},
+     {default_release_version, case rcl_state:default_release(State) of
+                                   {_, Vsn0} ->
+                                       Vsn0
+                               end},
+     {default_release, case rcl_state:default_release(State) of
+                           {Name1, undefined} ->
+                               erlang:atom_to_list(Name1);
+                           {Name1, Vsn1} ->
+                               erlang:atom_to_list(Name1) ++ "-" ++ Vsn1
+                       end}].
+
+-spec do_overlay(rcl_state:t(), proplists:proplist()) ->
+                                   {ok, rcl_state:t()} | relcool:error().
+do_overlay(State, OverlayVars) ->
+    case rcl_state:get(State, overlay, undefined) of
+        undefined ->
+            {ok, State};
+        Overlays ->
+            handle_errors(State,
+                          ec_plists:map(fun(Overlay) ->
+                                                io:format("--->Doing ~p~n", [Overlay]),
+                                                Res = do_individual_overlay(State, OverlayVars,
+                                                                            Overlay),
+                                                io:format("-->Done ~p~n", [Overlay]),
+                                                Res
+                                        end, Overlays))
+    end.
+
+-spec handle_errors(rcl_state:t(), [ok | relcool:error()]) ->
+                           {ok, rcl_state:t()} | relcool:error().
+handle_errors(State, Result) ->
+    case [Error || Error <- Result,
+                   rcl_util:is_error(Error)] of
+        Errors = [_|_] ->
+            ?RCL_ERROR({overlay_failed, Errors});
+        [] ->
+            {ok, State}
+    end.
+
+-spec do_individual_overlay(rcl_state:t(), proplists:proplist(),
+                            OverlayDirective::term()) ->
+                                   {ok, rcl_state:t()} | relcool:error().
+do_individual_overlay(State, OverlayVars, {mkdir, Dir}) ->
+    ModuleName = make_template_name("rcl_mkdir_template", Dir),
+    io:format("compiling to ~p ~n", [ModuleName]),
+    case erlydtl:compile(erlang:iolist_to_binary(Dir), ModuleName) of
+        {ok, ModuleName} ->
+            io:format("compiled ~n"),
+            case render(ModuleName, OverlayVars) of
+                {ok, IoList} ->
+                    io:format("rendered ~n"),
+                    Absolute = filename:absname(filename:join(rcl_state:root_dir(State),
+                                                              erlang:iolist_to_binary(IoList))),
+                    io:format("got ~p ~n", [Absolute]),
+                    case rcl_util:mkdir_p(Absolute) of
+                        {error, Error} ->
+                            ?RCL_ERROR({unable_to_make_dir, Absolute, Error});
+                        ok ->
+                            ok
+                    end;
+                {error, Error} ->
+                    ?RCL_ERROR({dir_render_failed, Dir, Error})
+            end;
+        {error, Reason} ->
+            ?RCL_ERROR({unable_to_compile_template, Dir, Reason})
+    end;
+do_individual_overlay(State, OverlayVars, {copy, From, To}) ->
+    FromTemplateName = make_template_name("rcl_copy_from_template", From),
+    ToTemplateName = make_template_name("rcl_copy_to_template", To),
+    file_render_do(State, OverlayVars, From, FromTemplateName,
+                   fun(FromFile) ->
+                           file_render_do(State, OverlayVars, To, ToTemplateName,
+                                          fun(ToFile) ->
+                                                  filelib:ensure_dir(ToFile),
+                                                  case ec_file:copy(FromFile, ToFile) of
+                                                      ok ->
+                                                          ok;
+                                                      {error, Err} ->
+                                                          ?RCL_ERROR({copy_failed,
+                                                                      FromFile,
+                                                                      ToFile, Err})
+                                                  end
+                                          end)
+                   end);
+do_individual_overlay(State, OverlayVars, {template, From, To}) ->
+    FromTemplateName = make_template_name("rcl_template_from_template", From),
+    ToTemplateName = make_template_name("rcl_template_to_template", To),
+    file_render_do(State, OverlayVars, From, FromTemplateName,
+                   fun(FromFile) ->
+                           file_render_do(State, OverlayVars, To, ToTemplateName,
+                                          fun(ToFile) ->
+                                                  render_template(OverlayVars,
+                                                                  erlang:binary_to_list(FromFile),
+                                                                  ToFile)
+                                          end)
+                   end).
+
+-spec render_template(proplists:proplist(), iolist(), file:name()) ->
+                             ok | relcool:error().
+render_template(OverlayVars, FromFile, ToFile) ->
+    TemplateName = make_template_name("rcl_template_renderer", FromFile),
+    case erlydtl:compile(FromFile, TemplateName) of
+        Good when Good =:= ok; ok =:= {ok, TemplateName} ->
+            case render(TemplateName, OverlayVars) of
+                {ok, IoData} ->
+                    io:format("Rendering ~p~n", [IoData]),
+                    case filelib:ensure_dir(ToFile) of
+                        ok ->
+                            case file:write_file(ToFile, IoData) of
+                                ok ->
+                                    ok;
+                                {error, Reason} ->
+                                    ?RCL_ERROR({unable_to_write, ToFile, Reason})
+                            end;
+                        {error, Reason} ->
+                            ?RCL_ERROR({unable_to_enclosing_dir, ToFile, Reason})
+                    end;
+                {error, Reason} ->
+                    ?RCL_ERROR({unable_to_render_template, FromFile, Reason})
+            end;
+        {error, Reason} ->
+            ?RCL_ERROR({unable_to_compile_template, FromFile, Reason})
+    end.
+
+-spec file_render_do(rcl_state:t(), proplists:proplist(), iolist(), module(),
+                     fun((term()) -> {ok, rcl_state:t()} | relcool:error())) ->
+                            {ok, rcl_state:t()} | relcool:error().
+file_render_do(State, OverlayVars, Data, TemplateName, NextAction) ->
+    case erlydtl:compile(erlang:iolist_to_binary(Data), TemplateName) of
+        {ok, TemplateName} ->
+            case render(TemplateName, OverlayVars) of
+                {ok, IoList} ->
+                    Absolute = filename:absname(filename:join(rcl_state:root_dir(State),
+                                                              erlang:iolist_to_binary(IoList))),
+                    NextAction(Absolute);
+                {error, Error} ->
+                    ?RCL_ERROR({render_failed, Data, Error})
+            end;
+        {error, Reason} ->
+            ?RCL_ERROR({unable_to_compile_template, Data, Reason})
+    end.
+
+-spec make_template_name(string(), term()) -> module().
+make_template_name(Base, Value) ->
+    %% Seed so we get different values each time
+    random:seed(erlang:now()),
+    Hash = erlang:phash2(Value),
+    Ran = random:uniform(10000000),
+    erlang:list_to_atom(Base ++ "_" ++
+                            erlang:integer_to_list(Hash) ++
+                            "_" ++ erlang:integer_to_list(Ran)).
+
+-spec render(module(), proplists:proplist()) -> {ok, iolist()} | {error, Reason::term()}.
+render(ModuleName, OverlayVars) ->
+    try
+        ModuleName:render(OverlayVars)
+    catch
+        _:Reason ->
+            {error, Reason}
+    end.