aboutsummaryrefslogtreecommitdiffstats
path: root/src/rlx_prv_overlay.erl
diff options
context:
space:
mode:
Diffstat (limited to 'src/rlx_prv_overlay.erl')
-rw-r--r--src/rlx_prv_overlay.erl418
1 files changed, 418 insertions, 0 deletions
diff --git a/src/rlx_prv_overlay.erl b/src/rlx_prv_overlay.erl
new file mode 100644
index 0000000..5fffd78
--- /dev/null
+++ b/src/rlx_prv_overlay.erl
@@ -0,0 +1,418 @@
+%% -*- erlang-indent-level: 4; indent-tabs-mode: nil; fill-column: 80 -*-
+%%% 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(rlx_prv_overlay).
+
+-behaviour(rlx_provider).
+
+-export([init/1,
+ do/1,
+ format_error/1]).
+
+-define(DIRECTORY_RE, ".*(\/|\\\\)$").
+
+-include_lib("relx/include/relx.hrl").
+
+%%============================================================================
+%% API
+%%============================================================================
+-spec init(rlx_state:t()) -> {ok, rlx_state:t()}.
+init(State) ->
+ {ok, State}.
+
+%% @doc recursively dig down into the library directories specified in the state
+%% looking for OTP Applications
+-spec do(rlx_state:t()) -> {ok, rlx_state:t()} | relx:error().
+do(State) ->
+ {RelName, RelVsn} = rlx_state:default_configured_release(State),
+ Release = rlx_state:get_realized_release(State, RelName, RelVsn),
+ case rlx_release:realized(Release) of
+ true ->
+ generate_overlay_vars(State, Release);
+ false ->
+ ?RLX_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(rlx_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, rlx_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(rlx_state:t(), rlx_release:t()) ->
+ {ok, rlx_state:t()} | relx: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(rlx_state:t(), proplists:proplist()) ->
+ {ok, rlx_state:t()} | relx:error().
+get_overlay_vars_from_file(State, OverlayVars) ->
+ case rlx_state:get(State, overlay_vars, undefined) of
+ undefined ->
+ do_overlay(State, OverlayVars);
+ FileName ->
+ read_overlay_vars(State, OverlayVars, FileName)
+ end.
+
+-spec read_overlay_vars(rlx_state:t(), proplists:proplist(), file:name()) ->
+ {ok, rlx_state:t()} | relx:error().
+read_overlay_vars(State, OverlayVars, FileName) ->
+ RelativeRoot = get_relative_root(State),
+ RelativePath = filename:join(RelativeRoot, erlang:iolist_to_binary(FileName)),
+ case file:consult(RelativePath) of
+ {ok, Terms} ->
+ case render_overlay_vars(OverlayVars, Terms, []) of
+ {ok, NewTerms} ->
+ do_overlay(State, NewTerms ++ OverlayVars);
+ Error ->
+ Error
+ end;
+ {error, Reason} ->
+ ?RLX_ERROR({unable_to_read_varsfile, FileName, Reason})
+ end.
+
+-spec render_overlay_vars(proplists:proplist(), proplists:proplist(),
+ proplists:proplist()) ->
+ {ok, proplists:proplist()} | relx:error().
+render_overlay_vars(OverlayVars, [{Key, Value} | Rest], Acc)
+ when erlang:is_list(Value) ->
+ case io_lib:printable_list(Value) of
+ true ->
+ case render_template(Acc ++ OverlayVars, erlang:iolist_to_binary(Value)) of
+ {ok, Data} ->
+ %% Adding to the end sucks, but ordering needs to be retained
+ render_overlay_vars(OverlayVars, Rest, Acc ++ [{Key, Data}]);
+ Error ->
+ Error
+ end;
+ false ->
+ case render_overlay_vars(Acc ++ OverlayVars, Value, []) of
+ {ok, NewValue} ->
+ render_overlay_vars(OverlayVars, Rest, Acc ++ [{Key, NewValue}]);
+ Error ->
+ Error
+ end
+ end;
+render_overlay_vars(OverlayVars, [{Key, Value} | Rest], Acc)
+ when erlang:is_binary(Value) ->
+ case render_template(Acc ++ OverlayVars, erlang:iolist_to_binary(Value)) of
+ {ok, Data} ->
+ render_overlay_vars(OverlayVars, Rest, Acc ++ [{Key, erlang:iolist_to_binary(Data)}]);
+ Error ->
+ Error
+ end;
+render_overlay_vars(OverlayVars, [KeyValue | Rest], Acc) ->
+ render_overlay_vars(OverlayVars, Rest, Acc ++ [KeyValue]);
+render_overlay_vars(_OverlayVars, [], Acc) ->
+ {ok, Acc}.
+
+-spec generate_release_vars(rlx_release:t()) -> proplists:proplist().
+generate_release_vars(Release) ->
+ [{erts_vsn, rlx_release:erts(Release)},
+ {release_erts_version, rlx_release:erts(Release)},
+ {release_name, rlx_release:name(Release)},
+ {rel_vsn, rlx_release:vsn(Release)},
+ {release_version, rlx_release:vsn(Release)},
+ {release_applications, lists:map(fun(App) ->
+ rlx_app_info:name(App)
+ end, rlx_release:application_details(Release))},
+ {release, [generate_app_vars(App)|| App <- rlx_release:application_details(Release)]},
+ {release_goals, [if
+ erlang:is_list(Constraint) ->
+ Constraint;
+ true ->
+ rlx_depsolver:format_constraint(Constraint)
+ end || Constraint <- rlx_release:goals(Release)]}].
+
+-spec generate_app_vars(rlx_app_info:t()) -> AppInfo::tuple().
+generate_app_vars(App) ->
+ {rlx_app_info:name(App),
+ [{version, rlx_app_info:vsn_as_string(App)},
+ {dir, rlx_app_info:dir(App)},
+ {active_dependencies, rlx_app_info:active_deps(App)},
+ {library_dependencies, rlx_app_info:library_deps(App)},
+ {link, rlx_app_info:link(App)}]}.
+
+-spec generate_state_vars(rlx_state:t()) -> proplists:proplist().
+generate_state_vars(State) ->
+ [{log, rlx_log:format(rlx_state:log(State))},
+ {output_dir, rlx_state:output_dir(State)},
+ {target_dir, rlx_state:output_dir(State)},
+ {overridden, [AppName || {AppName, _} <- rlx_state:overrides(State)]},
+ {overrides, rlx_state:overrides(State)},
+ {goals, [rlx_depsolver:format_constraint(Constraint) ||
+ Constraint <- rlx_state:goals(State)]},
+ {lib_dirs, rlx_state:lib_dirs(State)},
+ {config_file, rlx_state:config_file(State)},
+ {providers, rlx_state:providers(State)},
+ {sys_config, rlx_state:sys_config(State)},
+ {root_dir, rlx_state:root_dir(State)},
+ {default_release_name, case rlx_state:default_configured_release(State) of
+ {Name0, _} ->
+ Name0
+ end},
+ {default_release_version, case rlx_state:default_configured_release(State) of
+ {_, Vsn0} ->
+ Vsn0
+ end},
+ {default_release, case rlx_state:default_configured_release(State) of
+ {Name1, undefined} ->
+ erlang:atom_to_list(Name1);
+ {Name1, Vsn1} ->
+ erlang:atom_to_list(Name1) ++ "-" ++ Vsn1
+ end}].
+
+-spec do_overlay(rlx_state:t(), proplists:proplist()) ->
+ {ok, rlx_state:t()} | relx:error().
+do_overlay(State, OverlayVars) ->
+ case rlx_state:get(State, overlay, undefined) of
+ undefined ->
+ {ok, State};
+ Overlays ->
+ handle_errors(State,
+ lists:map(fun(Overlay) ->
+ do_individual_overlay(State, OverlayVars,
+ Overlay)
+ end, Overlays))
+ end.
+
+-spec handle_errors(rlx_state:t(), [ok | relx:error()]) ->
+ {ok, rlx_state:t()} | relx:error().
+handle_errors(State, Result) ->
+ case [Error || Error <- Result,
+ rlx_util:is_error(Error)] of
+ Errors = [_|_] ->
+ ?RLX_ERROR({overlay_failed, Errors});
+ [] ->
+ {ok, State}
+ end.
+
+-spec do_individual_overlay(rlx_state:t(), proplists:proplist(),
+ OverlayDirective::term()) ->
+ {ok, rlx_state:t()} | relx:error().
+do_individual_overlay(State, OverlayVars, {mkdir, Dir}) ->
+ ModuleName = make_template_name("rlx_mkdir_template", Dir),
+ case erlydtl:compile(erlang:iolist_to_binary(Dir), ModuleName) of
+ {ok, ModuleName} ->
+ case render(ModuleName, OverlayVars) of
+ {ok, IoList} ->
+ Absolute = absolutize(State,
+ filename:join(rlx_state:output_dir(State),
+ erlang:iolist_to_binary(IoList))),
+ case rlx_util:mkdir_p(Absolute) of
+ {error, Error} ->
+ ?RLX_ERROR({unable_to_make_dir, Absolute, Error});
+ ok ->
+ ok
+ end;
+ {error, Error} ->
+ ?RLX_ERROR({dir_render_failed, Dir, Error})
+ end;
+ {error, Reason} ->
+ ?RLX_ERROR({unable_to_compile_template, Dir, Reason})
+ end;
+do_individual_overlay(State, OverlayVars, {copy, From, To}) ->
+ FromTemplateName = make_template_name("rlx_copy_from_template", From),
+ ToTemplateName = make_template_name("rlx_copy_to_template", To),
+ file_render_do(OverlayVars, From, FromTemplateName,
+ fun(FromFile) ->
+ file_render_do(OverlayVars, To, ToTemplateName,
+ fun(ToFile) ->
+ copy_to(State, FromFile, ToFile)
+ end)
+ end);
+do_individual_overlay(State, OverlayVars, {template, From, To}) ->
+ FromTemplateName = make_template_name("rlx_template_from_template", From),
+ ToTemplateName = make_template_name("rlx_template_to_template", To),
+ file_render_do(OverlayVars, From, FromTemplateName,
+ fun(FromFile) ->
+ file_render_do(OverlayVars, To, ToTemplateName,
+ fun(ToFile) ->
+ RelativeRoot = get_relative_root(State),
+ FromFile0 = absolutize(State,
+ filename:join(RelativeRoot,
+ erlang:iolist_to_binary(FromFile))),
+ FromFile1 = erlang:binary_to_list(FromFile0),
+ write_template(OverlayVars,
+ FromFile1,
+ absolutize(State,
+ filename:join(rlx_state:output_dir(State),
+ erlang:iolist_to_binary(ToFile))))
+ end)
+ end).
+
+-spec copy_to(rlx_state:t(), file:name(), file:name()) -> ok | relx:error().
+copy_to(State, FromFile0, ToFile0) ->
+ RelativeRoot = get_relative_root(State),
+ ToFile1 = absolutize(State, filename:join(rlx_state:output_dir(State),
+ erlang:iolist_to_binary(ToFile0))),
+
+ FromFile1 = absolutize(State, filename:join(RelativeRoot,
+ erlang:iolist_to_binary(FromFile0))),
+ ToFile2 = case is_directory(ToFile0, ToFile1) of
+ false ->
+ filelib:ensure_dir(ToFile1),
+ ToFile1;
+ true ->
+ rlx_util:mkdir_p(ToFile1),
+ erlang:iolist_to_binary(filename:join(ToFile1,
+ filename:basename(FromFile1)))
+ end,
+ case ec_file:copy(FromFile1, ToFile2) of
+ ok ->
+ {ok, FileInfo} = file:read_file_info(FromFile1),
+ ok = file:write_file_info(ToFile2, FileInfo),
+ ok;
+ {error, Err} ->
+ ?RLX_ERROR({copy_failed,
+ FromFile1,
+ ToFile1, Err})
+ end.
+
+get_relative_root(State) ->
+ case rlx_state:config_file(State) of
+ [] ->
+ rlx_state:root_dir(State);
+ Config ->
+ filename:dirname(Config)
+ end.
+
+-spec is_directory(file:name(), file:name()) -> boolean().
+is_directory(ToFile0, ToFile1) ->
+ case re:run(ToFile0, ?DIRECTORY_RE) of
+ nomatch ->
+ filelib:is_dir(ToFile1);
+ _ ->
+ true
+ end.
+
+
+-spec render_template(proplists:proplist(), iolist()) ->
+ ok | relx:error().
+render_template(OverlayVars, Data) ->
+ TemplateName = make_template_name("rlx_template_renderer", Data),
+ case erlydtl:compile(Data, TemplateName) of
+ Good when Good =:= ok; Good =:= {ok, TemplateName} ->
+ case render(TemplateName, OverlayVars) of
+ {ok, IoData} ->
+ {ok, IoData};
+ {error, Reason} ->
+ ?RLX_ERROR({unable_to_render_template, Data, Reason})
+ end;
+ {error, Reason} ->
+ ?RLX_ERROR({unable_to_compile_template, Data, Reason})
+ end.
+
+write_template(OverlayVars, FromFile, ToFile) ->
+ case render_template(OverlayVars, FromFile) of
+ {ok, IoData} ->
+ case filelib:ensure_dir(ToFile) of
+ ok ->
+ case file:write_file(ToFile, IoData) of
+ ok ->
+ {ok, FileInfo} = file:read_file_info(FromFile),
+ ok = file:write_file_info(ToFile, FileInfo),
+ ok;
+ {error, Reason} ->
+ ?RLX_ERROR({unable_to_write, ToFile, Reason})
+ end;
+ {error, Reason} ->
+ ?RLX_ERROR({unable_to_enclosing_dir, ToFile, Reason})
+ end;
+ Error ->
+ Error
+ end.
+
+-spec file_render_do(proplists:proplist(), iolist(), module(),
+ fun((term()) -> {ok, rlx_state:t()} | relx:error())) ->
+ {ok, rlx_state:t()} | relx:error().
+file_render_do(OverlayVars, Data, TemplateName, NextAction) ->
+ case erlydtl:compile(erlang:iolist_to_binary(Data), TemplateName) of
+ {ok, TemplateName} ->
+ case render(TemplateName, OverlayVars) of
+ {ok, IoList} ->
+ NextAction(IoList);
+ {error, Error} ->
+ ?RLX_ERROR({render_failed, Data, Error})
+ end;
+ {error, Reason} ->
+ ?RLX_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.
+
+absolutize(State, FileName) ->
+ filename:absname(filename:join(rlx_state:root_dir(State),
+ erlang:iolist_to_binary(FileName))).