458 lines
12 KiB
Erlang
458 lines
12 KiB
Erlang
%%% ====================================================================
|
|
%%% ``The contents of this file are subject to the Erlang Public License,
|
|
%%% Version 1.1, (the "License"); you may not use this file except in
|
|
%%% compliance with the License. You should have received a copy of the
|
|
%%% Erlang Public License along with this software. If not, it can be
|
|
%%% retrieved via the world wide web at http://www.erlang.org/.
|
|
%%%
|
|
%%% Software distributed under the License is distributed on an "AS IS"
|
|
%%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
|
|
%%% the License for the specific language governing rights and limitations
|
|
%%% under the License.
|
|
%%%
|
|
%%% @author Brian Cully <bjc@kublai.com>
|
|
%%% @version {@vsn}, {@date} {@time}
|
|
%%% @end
|
|
%%% ====================================================================
|
|
|
|
-module(nodetree_dag).
|
|
-author('bjc@kublai.com').
|
|
|
|
%% API
|
|
-export([init/3,
|
|
terminate/2,
|
|
options/0,
|
|
set_node/1,
|
|
get_node/3,
|
|
get_node/2,
|
|
get_node/1,
|
|
get_nodes/2,
|
|
get_nodes/1,
|
|
get_parentnodes/3,
|
|
get_parentnodes_tree/3,
|
|
get_subnodes/3,
|
|
get_subnodes_tree/3,
|
|
create_node/6,
|
|
delete_node/2]).
|
|
|
|
-include_lib("stdlib/include/qlc.hrl").
|
|
|
|
-include("ejabberd.hrl").
|
|
-include("pubsub.hrl").
|
|
|
|
-behaviour(gen_pubsub_nodetree).
|
|
|
|
-define(DEFAULT_NODETYPE, leaf).
|
|
-define(DEFAULT_PARENTS, []).
|
|
-define(DEFAULT_CHILDREN, []).
|
|
|
|
-compile(export_all).
|
|
|
|
%%====================================================================
|
|
%% API
|
|
%%====================================================================
|
|
-spec(init/3 ::
|
|
(
|
|
Host :: string(),
|
|
ServerHost :: string(),
|
|
Opts :: [{Key::atom(), Value::term()}])
|
|
-> 'ok'
|
|
).
|
|
|
|
init(Host, ServerHost, Opts) ->
|
|
nodetree_tree:init(Host, ServerHost, Opts).
|
|
|
|
|
|
-spec(terminate/2 ::
|
|
(
|
|
Host :: string(),
|
|
ServerHost :: string())
|
|
-> 'ok'
|
|
).
|
|
|
|
terminate(Host, ServerHost) ->
|
|
nodetree_tree:terminate(Host, ServerHost).
|
|
|
|
|
|
-spec(create_node/6 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId(),
|
|
Type :: nodeType(),
|
|
JID :: jidEntity(),
|
|
Options :: [nodeOption()],
|
|
ParentNodeIds :: [] | [nodeId()])
|
|
-> {'ok', NodeIdx::nodeIdx()} | {'error', _}
|
|
).
|
|
|
|
create_node(Host, NodeId, Type, #jid{node = U, domain = S} = _JID, Options, ParentNodeIds) ->
|
|
case find_node(Host, NodeId) of
|
|
false ->
|
|
NodeIdx = pubsub_index:new(node),
|
|
Node = #pubsub_node{id = {Host, NodeId},
|
|
idx = NodeIdx,
|
|
type = Type,
|
|
parents = ParentNodeIds,
|
|
owners = [_Owner = {U,S,undefined}],
|
|
options = Options},
|
|
case set_node(Node) of
|
|
ok -> {ok, NodeIdx};
|
|
Other -> Other
|
|
end;
|
|
_ ->
|
|
{error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'conflict')}
|
|
end.
|
|
|
|
|
|
-spec(set_node/1 ::
|
|
(
|
|
Node :: pubsubNode())
|
|
-> 'ok' | {'error', _}
|
|
).
|
|
|
|
set_node(#pubsub_node{id = {Host, _},
|
|
owners = Owners,
|
|
options = Options} = Node) ->
|
|
ParentNodeIds = find_opt('collection', ?DEFAULT_PARENTS, Options),
|
|
case validate_parentage(Host, Owners, ParentNodeIds) of
|
|
true ->
|
|
%% Update parents whenever the config changes.
|
|
mnesia:write(Node#pubsub_node{parents = ParentNodeIds});
|
|
Other ->
|
|
Other
|
|
end.
|
|
|
|
|
|
-spec(delete_node/2 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId())
|
|
-> [pubsubNode()] | {'error', _}
|
|
).
|
|
|
|
delete_node(Host, NodeId) ->
|
|
case find_node(Host, NodeId) of
|
|
false ->
|
|
{error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'item-not-found')};
|
|
ParentNode ->
|
|
%% Find all of N's children, update their configs to
|
|
%% remove N from the collection setting.
|
|
lists:foreach(fun (#pubsub_node{options = Options} = Node) ->
|
|
NewOptions = remove_config_parent(NodeId, Options),
|
|
Parents = find_opt('collection', ?DEFAULT_PARENTS, NewOptions),
|
|
ok = mnesia:write(pubsub_node,
|
|
Node#pubsub_node{
|
|
parents = Parents,
|
|
options = NewOptions},
|
|
write)
|
|
end, get_subnodes(Host, NodeId)),
|
|
|
|
%% Remove and return the requested node.
|
|
pubsub_index:free(node, ParentNode#pubsub_node.idx),
|
|
mnesia:delete_object(pubsub_node, ParentNode, write),
|
|
[ParentNode]
|
|
end.
|
|
|
|
|
|
-spec(options/0 :: () -> Options::[Option::nodeOption()]).
|
|
%Options::[{'virtual_tree', 'false'}])
|
|
|
|
options() -> nodetree_tree:options().
|
|
|
|
|
|
-spec(get_node/3 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId(),
|
|
JID :: jidEntity())
|
|
-> pubsubNode() | {'error', _}
|
|
).
|
|
|
|
get_node(Host, NodeId, _JID) ->
|
|
get_node(Host, NodeId).
|
|
|
|
|
|
-spec(get_node/2 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId())
|
|
-> pubsubNode() | {'error', _}
|
|
).
|
|
|
|
get_node(Host, NodeId) ->
|
|
case find_node(Host, NodeId) of
|
|
false -> {error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'item-not-found')};
|
|
Node -> Node
|
|
end.
|
|
|
|
|
|
-spec(get_node/1 ::
|
|
(
|
|
NodeIdx :: nodeIdx())
|
|
-> pubsubNode() | {'error', 'item-not-found'}
|
|
).
|
|
|
|
get_node(NodeIdx) ->
|
|
nodetree_tree:get_node(NodeIdx).
|
|
|
|
|
|
-spec(get_nodes/2 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
JID :: jidEntity())
|
|
-> Nodes :: [] | [Node::pubsubNode()]
|
|
).
|
|
|
|
get_nodes(Host, JID) ->
|
|
nodetree_tree:get_nodes(Host, JID).
|
|
|
|
|
|
-spec(get_nodes/1 ::
|
|
(
|
|
Host :: hostPubsub())
|
|
-> Nodes :: [] | [Node::pubsubNode()]
|
|
).
|
|
|
|
get_nodes(Host) ->
|
|
nodetree_tree:get_nodes(Host).
|
|
|
|
|
|
-spec(get_parentnodes/3 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId(),
|
|
JID :: jidEntity())
|
|
-> ParentNodes :: [] | [ParentNode::pubsubNode()]
|
|
).
|
|
|
|
get_parentnodes(Host, NodeId, _JID) ->
|
|
case find_node(Host, NodeId) of
|
|
false -> {error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'item-not-found')};
|
|
#pubsub_node{parents = ParentNodeIds} ->
|
|
Q = qlc:q([Node || #pubsub_node{id = {NHost, NNodeId}} = Node
|
|
<- mnesia:table(pubsub_node),
|
|
ParentNodeId <- ParentNodeIds,
|
|
Host == NHost,
|
|
ParentNodeId == NNodeId]),
|
|
qlc:e(Q)
|
|
end.
|
|
|
|
|
|
-spec(get_parentnodes_tree/3 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId(),
|
|
JID :: jidEntity())
|
|
-> [] | [{Depth::integer(), Nodes :: [] | [Node::pubsubNode()]}]
|
|
).
|
|
|
|
get_parentnodes_tree(Host, NodeId, _JID) ->
|
|
Pred = fun (Name, #pubsub_node{id = {_, NodeName}}) -> Name == NodeName end,
|
|
Tr = fun (#pubsub_node{parents = Parents}) -> Parents end,
|
|
traversal_helper(Pred, Tr, Host, [NodeId]).
|
|
|
|
|
|
-spec(get_subnodes/3 ::
|
|
(
|
|
ParentNodeHost :: hostPubsub(),
|
|
ParentNodeId :: nodeId(),
|
|
JID :: jidEntity())
|
|
-> [] | [Node::pubsubNode()] | {'error', _}
|
|
).
|
|
|
|
get_subnodes(Host, Node, _JID) ->
|
|
get_subnodes(Host, Node).
|
|
|
|
|
|
-spec(get_subnodes/2 ::
|
|
(
|
|
ParentNodeHost :: hostPubsub(),
|
|
ParentNodeId :: nodeId())
|
|
-> [] | [Node::pubsubNode()] | {'error', _}
|
|
).
|
|
|
|
get_subnodes(ParentNodeHost, <<>>) ->
|
|
get_subnodes_helper(ParentNodeHost, <<>>);
|
|
get_subnodes(ParentNodeHost, ParentNodeId) ->
|
|
case find_node(ParentNodeHost, ParentNodeId) of
|
|
false -> {error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'item-not-found')};
|
|
_ -> get_subnodes_helper(ParentNodeHost, ParentNodeId)
|
|
end.
|
|
|
|
|
|
-spec(get_subnodes_helper/2 ::
|
|
(
|
|
ParentNodeHost :: hostPubsub(),
|
|
ParentNodeId :: nodeId())
|
|
-> SubNodes :: [] | [Node::pubsubNode()]
|
|
).
|
|
|
|
get_subnodes_helper(ParentNodeHost, ParentNodeId) ->
|
|
Q = qlc:q([Node || #pubsub_node{id = {Host, _},
|
|
parents = ParentNodeIds} = Node <- mnesia:table(pubsub_node),
|
|
ParentNodeHost == Host,
|
|
lists:member(ParentNodeId, ParentNodeIds)]),
|
|
qlc:e(Q).
|
|
|
|
|
|
-spec(get_subnodes_tree/3 ::
|
|
(
|
|
ParentNodeHost :: hostPubsub(),
|
|
ParentNodeId :: nodeId(),
|
|
JID :: jidEntity())
|
|
-> [] | [{Depth::integer(), Nodes :: [] | [Node::pubsubNode()]}]
|
|
).
|
|
|
|
get_subnodes_tree(Host, ParentNodeId, JID) ->
|
|
Pred = fun(NodeId, #pubsub_node{parents = ParentNodeIds}) ->
|
|
lists:member(NodeId, ParentNodeIds)
|
|
end,
|
|
Tr = fun (#pubsub_node{id = {_, NodeId}}) -> [NodeId] end,
|
|
traversal_helper(Pred, Tr, 1, Host, [ParentNodeId],
|
|
[{0, [get_node(Host, ParentNodeId, JID)]}]).
|
|
|
|
%%====================================================================
|
|
%% Internal functions
|
|
%%====================================================================
|
|
oid(Key, Name) -> {Key, Name}.
|
|
|
|
%% Key = jlib:jid() | host()
|
|
%% Node = string()
|
|
-spec(find_node/2 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
NodeId :: nodeId())
|
|
-> pubsubNode() | 'false'
|
|
).
|
|
|
|
find_node(Host, NodeId) ->
|
|
case mnesia:read({pubsub_node, {Host, NodeId}}) of
|
|
[] -> false;
|
|
[Node] -> Node
|
|
end.
|
|
|
|
%% Key = jlib:jid() | host()
|
|
%% Default = term()
|
|
%% Options = [{Key = atom(), Value = term()}]
|
|
-spec(find_opt/3 ::
|
|
(
|
|
Key :: atom(),
|
|
Default :: term(),
|
|
Options :: [Option::nodeOption()])
|
|
-> Value::term()
|
|
).
|
|
|
|
find_opt(Key, Default, Options) ->
|
|
case lists:keysearch(Key, 1, Options) of
|
|
{value, {Key, Value}} -> Value;
|
|
_ -> Default
|
|
end.
|
|
|
|
|
|
-spec(traversal_helper/4 ::
|
|
(
|
|
Pred :: fun(),
|
|
Tr :: fun(),
|
|
ParentNodeHost :: hostPubsub(),
|
|
ParentNodeIds :: [] | [ParentNodeId::nodeId()])
|
|
-> [] | [{Depth::integer(), Nodes :: [] | [Node::pubsubNode()]}]
|
|
).
|
|
|
|
traversal_helper(Pred, Tr, ParentNodeHost, ParentNodeIds) ->
|
|
traversal_helper(Pred, Tr, 0, ParentNodeHost, ParentNodeIds, []).
|
|
|
|
|
|
-spec(traversal_helper/6 ::
|
|
(
|
|
Pred :: fun(),
|
|
Tr :: fun(),
|
|
Depth :: integer(),
|
|
ParentNodeHost :: hostPubsub(),
|
|
ParentNodeIds :: [] | [ParentNodeId::nodeId()],
|
|
Acc :: [] | [{Depth::integer(), Nodes :: [] | [Node::pubsubNode()]}])
|
|
-> [] | [{Depth::integer(), Nodes :: [] | [Node::pubsubNode()]}]
|
|
).
|
|
|
|
traversal_helper(_Pred, _Tr, _Depth, _Host, [], Acc) ->
|
|
Acc;
|
|
traversal_helper(Pred, Tr, Depth, ParentNodeHost, ParentNodeIds, Acc) ->
|
|
Q = qlc:q([Node || #pubsub_node{id = {Host, _}} = Node <- mnesia:table(pubsub_node),
|
|
ParentNodeId <- ParentNodeIds,
|
|
ParentNodeHost == Host,
|
|
Pred(ParentNodeId, Node)]),
|
|
Nodes = qlc:e(Q),
|
|
Ids = lists:flatmap(Tr, Nodes),
|
|
traversal_helper(Pred, Tr, Depth + 1, ParentNodeHost, Ids, [{Depth, Nodes} | Acc]).
|
|
|
|
|
|
-spec(remove_config_parent/2 ::
|
|
(
|
|
NodeId :: nodeId(),
|
|
Options :: [Option::nodeOption()])
|
|
-> [Option::nodeOption()]
|
|
).
|
|
|
|
remove_config_parent(NodeId, Options) ->
|
|
remove_config_parent(NodeId, Options, []).
|
|
|
|
|
|
-spec(remove_config_parent/3 ::
|
|
(
|
|
NodeId :: nodeId(),
|
|
Options :: [] | [Option::nodeOption()],
|
|
Acc :: [Option::nodeOption()])
|
|
-> [Option::nodeOption()]
|
|
).
|
|
|
|
remove_config_parent(_NodeId, [], Acc) ->
|
|
lists:reverse(Acc);
|
|
remove_config_parent(NodeId, [{'collection', ParentNodeIds} | Options], Acc) ->
|
|
remove_config_parent(NodeId, Options,
|
|
[{'collection', lists:delete(NodeId, ParentNodeIds)} | Acc]);
|
|
remove_config_parent(NodeId, [Option | Options], Acc) ->
|
|
remove_config_parent(NodeId, Options, [Option | Acc]).
|
|
|
|
|
|
-spec(validate_parentage/3 ::
|
|
(
|
|
Host :: hostPubsub(),
|
|
Owners :: [Owner::bareUsr()],
|
|
ParentNodeIds :: [] | [ParentNodeId::nodeId()] | [ParentNodeId :: nodeId() | []])
|
|
-> 'true' | {'error', _}
|
|
).
|
|
|
|
validate_parentage(_Host, _Owners, []) ->
|
|
true;
|
|
validate_parentage(Host, Owners, [[] | ParentNodeIds]) ->
|
|
validate_parentage(Host, Owners, ParentNodeIds);
|
|
validate_parentage(Host, Owners, [<<>> | ParentNodeIds]) ->
|
|
validate_parentage(Host, Owners, ParentNodeIds);
|
|
validate_parentage(Host, Owners, [ParentNodeId | ParentNodeIds]) ->
|
|
case find_node(Host, ParentNodeId) of
|
|
false -> {error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'item_not_found')};
|
|
#pubsub_node{owners = ParentNodeOwners, options = Options} ->
|
|
NodeType = find_opt('node_type', ?DEFAULT_NODETYPE, Options),
|
|
MutualOwners = [Owner || Owner <- Owners, ParentNodeOwner <- ParentNodeOwners,
|
|
Owner == ParentNodeOwner],
|
|
case {MutualOwners, NodeType} of
|
|
{[], _} -> {error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'forbidden')};
|
|
{_, 'collection'} -> validate_parentage(Host, Owners, ParentNodeIds);
|
|
{_, _} -> {error, exmpp_stanza:error(?NS_JABBER_CLIENT, 'not-allowed')}
|
|
end
|
|
end.
|
|
|
|
%% @spec (Host) -> jid()
|
|
%% Host = host()
|
|
%% @doc <p>Generate pubsub service JID.</p>
|
|
-spec(service_jid/1 ::
|
|
(
|
|
Host :: hostPubsub())
|
|
-> ServiceJID :: jidContact() | jidComponent() %% should only return jidContact()
|
|
).
|
|
|
|
service_jid(Host) ->
|
|
case Host of
|
|
{U,S,_} -> exmpp_jid:make(U, S);
|
|
_ -> exmpp_jid:make(Host)
|
|
end.
|