#!/usr/bin/env escript %%% %%% Generate the verx.erl file %%% main(_) -> % load remote_protocol_xdr Path = os:getenv("REBAR_BUILD_DIR", filename:join( filename:dirname(escript:script_name()), "../_build/default" )), true = code:add_pathz(filename:join(Path, "lib/verx/ebin")), {module, remote_protocol_xdr} = code:load_file(remote_protocol_xdr), {{Year,_,_},{_,_,_}} = calendar:universal_time(), Date = integer_to_list(Year), Comment = [ " Copyright (c) 2011-" ++ Date ++ ", Michael Santos ", " All rights reserved.", "", " Redistribution and use in source and binary forms, with or without", " modification, are permitted provided that the following conditions", " are met:", "", " Redistributions of source code must retain the above copyright", " notice, this list of conditions and the following disclaimer.", "", " Redistributions in binary form must reproduce the above copyright", " notice, this list of conditions and the following disclaimer in the", " documentation and/or other materials provided with the distribution.", "", " Neither the name of the author nor the names of its contributors", " may be used to endorse or promote products derived from this software", " without specific prior written permission.", "", " THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS", " \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT", " LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS", " FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE", " COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,", " INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,", " BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;", " LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER", " CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT", " LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN", " ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE", " POSSIBILITY OF SUCH DAMAGE."], License = erl_syntax:comment(Comment), Module = erl_syntax:attribute( erl_syntax:atom(module), [erl_syntax:atom("verx")] ), Includes = includes(["verx.hrl"]), % Any hardcoded functions will be included here Static = erl_syntax:comment(["%__STATIC__%%"]), Calls = calls(), % Generate the list of exports Comment_static = erl_syntax:comment([" Static functions"]), Exports_static = erl_syntax:attribute(erl_syntax:atom(export), [ erl_syntax:list([ erl_syntax:arity_qualifier(erl_syntax:atom(Fun), erl_syntax:integer(Arity)) || {Fun, Arity} <- static_exports() ]) ]), Comment_gen = erl_syntax:comment([" Generated functions"]), Exports_gen = erl_syntax:attribute(erl_syntax:atom(export), [ erl_syntax:list([ erl_syntax:arity_qualifier(erl_syntax:atom(Fun), erl_syntax:integer(Arity+1)) || {Fun, _, Arity} <- Calls ]) ]), % Generate the functions Functions = [ begin {Pattern, Body} = case Arity of 0 -> % name(Ref) -> verx_client:call(Ref, 'PROC_NAME'). {[erl_syntax:variable("Ref")], erl_syntax:application( erl_syntax:atom(verx_client), erl_syntax:atom(call), [erl_syntax:variable("Ref"), erl_syntax:atom(Proc)] )}; _ -> % name(Ref, Arg) -> verx_client:call(Ref, 'PROC_NAME', Arg). {[erl_syntax:variable("Ref"), erl_syntax:variable("Arg")], erl_syntax:application( erl_syntax:atom(verx_client), erl_syntax:atom(call), [erl_syntax:variable("Ref"), erl_syntax:atom(Proc), erl_syntax:variable("Arg")] )} end, Clause = erl_syntax:clause(Pattern, [], [Body]), erl_syntax:function(erl_syntax:atom(Fun), [Clause]) end || {Fun, Proc, Arity} <- Calls ], Code0 = erl_prettypr:format(erl_syntax:form_list(lists:flatten([ License, Module, Includes, Comment_static, Exports_static, Comment_gen, Exports_gen, Static, Functions ]))), Code = re:replace(Code0, "%%__STATIC__%%", static()), io:format("~s~n", [Code]). % List the supported libvirt remote protocol procedures calls() -> % count from 1 until an exception is thrown calls(1, []). calls(N, Acc) -> try remote_protocol_xdr:dec_remote_procedure(<>, 0) of {Proc, _Off} -> calls(N+1, [Proc|Acc]) catch error:{case_clause,_} -> call_to_fun(lists:reverse(Acc)) end. call_to_fun(Calls) -> Exports = proplists:get_value(exports, remote_protocol_xdr:module_info()), [ begin "remote_proc_" ++ Name = string:to_lower(atom_to_list(N)), { Name, % function name N, % remote protocol procedure call_arity(Name, Exports) % number of arguments } end || N <- Calls ]. call_arity(Proc, Exports) -> Fun = list_to_atom("enc_remote_" ++ Proc ++ "_args"), proplists:get_value(Fun, Exports, 0). static_exports() -> [{connect_open, 1}, {open, 1}, {open, 2}, {close, 1}, {lookup, 2}]. static() -> [ static({Fun, Arity}) || {Fun, Arity} <- static_exports() ]. static({connect_open, 1}) -> " % Send a remote protocol open message % <<>> : name % 0 : flags % See: remote_protocol_xdr:enc_remote_connect_open_args/1 connect_open(Ref) -> connect_open(Ref, [<<>>, 0]). "; static({open, 1}) -> " % For backwards compatibility, use connect_open/1,2. open(Ref) -> connect_open(Ref, [<<>>, 0]). "; static({open, 2}) -> " open(Ref, Arg) -> connect_open(Ref, Arg). "; static({close, 1}) -> " close(Ref) -> connect_close(Ref). "; static({lookup, 2}) -> " lookup(Ref, {domain, Name}) -> Fun = [ fun() -> verx:domain_lookup_by_id(Ref, [maybe_integer(Name)]) end, fun() -> verx:domain_lookup_by_name(Ref, [maybe_binary(Name)]) end, fun() -> verx:domain_lookup_by_uuid(Ref, [uuid:string_to_uuid(Name)]) end, fun() -> verx:domain_lookup_by_uuid(Ref, [maybe_binary(Name)]) end ], lookup_1(Fun). lookup_1(Fun) -> lookup_1(Fun, []). lookup_1([], [{error, Error}|_]) -> {error, Error}; lookup_1([Fun|Tail], Acc) -> try Fun() of {ok, Res} -> {ok, Res}; {error, Error} -> lookup_1(Tail, [{error, Error}|Acc]) catch _:_ -> lookup_1(Tail, Acc) end. maybe_integer(N) when is_integer(N) -> N; maybe_integer(N) when is_list(N) -> list_to_integer(N). maybe_binary(N) when is_binary(N) -> N; maybe_binary(N) when is_list(N) -> list_to_binary(N). ". includes(Header) -> [ erl_syntax:attribute(erl_syntax:atom(include), [erl_syntax:string(N)]) || N <- Header ].