447 lines
12 KiB
Erlang
447 lines
12 KiB
Erlang
%%%----------------------------------------------------------------------
|
||
%%% File : pubsub_migrate.erl
|
||
%%% Author : Christophe Romain <christophe.romain@process-one.net>
|
||
%%% Purpose : Migration/Upgrade code put out of mod_pubsub
|
||
%%% Created : 26 Jul 2014 by Christophe Romain <christophe.romain@process-one.net>
|
||
%%%
|
||
%%%
|
||
%%% ejabberd, Copyright (C) 2002-2017 ProcessOne
|
||
%%%
|
||
%%% This program is free software; you can redistribute it and/or
|
||
%%% modify it under the terms of the GNU General Public License as
|
||
%%% published by the Free Software Foundation; either version 2 of the
|
||
%%% License, or (at your option) any later version.
|
||
%%%
|
||
%%% This program is distributed in the hope that it will be useful,
|
||
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
%%% General Public License for more details.
|
||
%%%
|
||
%%% You should have received a copy of the GNU General Public License along
|
||
%%% with this program; if not, write to the Free Software Foundation, Inc.,
|
||
%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
%%%
|
||
%%%----------------------------------------------------------------------
|
||
|
||
-module(pubsub_migrate).
|
||
|
||
-include("pubsub.hrl").
|
||
-include("logger.hrl").
|
||
|
||
-export([update_node_database/2, update_state_database/2]).
|
||
-export([update_item_database/2, update_lastitem_database/2]).
|
||
|
||
update_item_database(_Host, _ServerHost) ->
|
||
convert_list_items().
|
||
|
||
update_node_database(Host, ServerHost) ->
|
||
mnesia:del_table_index(pubsub_node, type),
|
||
mnesia:del_table_index(pubsub_node, parentid),
|
||
case catch mnesia:table_info(pubsub_node, attributes) of
|
||
[host_node, host_parent, info] ->
|
||
?INFO_MSG("Upgrading pubsub nodes table...", []),
|
||
F = fun () ->
|
||
{Result, LastIdx} = lists:foldl(fun ({pubsub_node,
|
||
NodeId, ParentId,
|
||
{nodeinfo, Items,
|
||
Options,
|
||
Entities}},
|
||
{RecList,
|
||
NodeIdx}) ->
|
||
ItemsList =
|
||
lists:foldl(fun
|
||
({item,
|
||
IID,
|
||
Publisher,
|
||
Payload},
|
||
Acc) ->
|
||
C =
|
||
{unknown,
|
||
Publisher},
|
||
M =
|
||
{p1_time_compat:timestamp(),
|
||
Publisher},
|
||
mnesia:write(#pubsub_item{itemid
|
||
=
|
||
{IID,
|
||
NodeIdx},
|
||
creation
|
||
=
|
||
C,
|
||
modification
|
||
=
|
||
M,
|
||
payload
|
||
=
|
||
Payload}),
|
||
[{Publisher,
|
||
IID}
|
||
| Acc]
|
||
end,
|
||
[],
|
||
Items),
|
||
Owners =
|
||
dict:fold(fun
|
||
(JID,
|
||
{entity,
|
||
Aff,
|
||
Sub},
|
||
Acc) ->
|
||
UsrItems =
|
||
lists:foldl(fun
|
||
({P,
|
||
I},
|
||
IAcc) ->
|
||
case
|
||
P
|
||
of
|
||
JID ->
|
||
[I
|
||
| IAcc];
|
||
_ ->
|
||
IAcc
|
||
end
|
||
end,
|
||
[],
|
||
ItemsList),
|
||
mnesia:write({pubsub_state,
|
||
{JID,
|
||
NodeIdx},
|
||
UsrItems,
|
||
Aff,
|
||
Sub}),
|
||
case
|
||
Aff
|
||
of
|
||
owner ->
|
||
[JID
|
||
| Acc];
|
||
_ ->
|
||
Acc
|
||
end
|
||
end,
|
||
[],
|
||
Entities),
|
||
mnesia:delete({pubsub_node,
|
||
NodeId}),
|
||
{[#pubsub_node{nodeid
|
||
=
|
||
NodeId,
|
||
id
|
||
=
|
||
NodeIdx,
|
||
parents
|
||
=
|
||
[element(2,
|
||
ParentId)],
|
||
owners
|
||
=
|
||
Owners,
|
||
options
|
||
=
|
||
Options}
|
||
| RecList],
|
||
NodeIdx + 1}
|
||
end,
|
||
{[], 1},
|
||
mnesia:match_object({pubsub_node,
|
||
{Host,
|
||
'_'},
|
||
'_',
|
||
'_'})),
|
||
mnesia:write(#pubsub_index{index = node, last = LastIdx,
|
||
free = []}),
|
||
Result
|
||
end,
|
||
{atomic, NewRecords} = mnesia:transaction(F),
|
||
{atomic, ok} = mnesia:delete_table(pubsub_node),
|
||
{atomic, ok} = ejabberd_mnesia:create(?MODULE, pubsub_node,
|
||
[{disc_copies, [node()]},
|
||
{attributes,
|
||
record_info(fields,
|
||
pubsub_node)}]),
|
||
FNew = fun () ->
|
||
lists:foreach(fun (Record) -> mnesia:write(Record) end,
|
||
NewRecords)
|
||
end,
|
||
case mnesia:transaction(FNew) of
|
||
{atomic, Result} ->
|
||
?INFO_MSG("Pubsub nodes table upgraded: ~p",
|
||
[Result]);
|
||
{aborted, Reason} ->
|
||
?ERROR_MSG("Problem upgrading Pubsub nodes table:~n~p",
|
||
[Reason])
|
||
end;
|
||
[nodeid, parentid, type, owners, options] ->
|
||
F = fun ({pubsub_node, NodeId, {_, Parent}, Type,
|
||
Owners, Options}) ->
|
||
#pubsub_node{nodeid = NodeId, id = 0,
|
||
parents = [Parent], type = Type,
|
||
owners = Owners, options = Options}
|
||
end,
|
||
mnesia:transform_table(pubsub_node, F,
|
||
[nodeid, id, parents, type, owners, options]),
|
||
FNew = fun () ->
|
||
LastIdx = lists:foldl(fun (#pubsub_node{nodeid =
|
||
NodeId} =
|
||
PubsubNode,
|
||
NodeIdx) ->
|
||
mnesia:write(PubsubNode#pubsub_node{id
|
||
=
|
||
NodeIdx}),
|
||
lists:foreach(fun
|
||
(#pubsub_state{stateid
|
||
=
|
||
StateId} =
|
||
State) ->
|
||
{JID,
|
||
_} =
|
||
StateId,
|
||
mnesia:delete({pubsub_state,
|
||
StateId}),
|
||
mnesia:write(State#pubsub_state{stateid
|
||
=
|
||
{JID,
|
||
NodeIdx}})
|
||
end,
|
||
mnesia:match_object(#pubsub_state{stateid
|
||
=
|
||
{'_',
|
||
NodeId},
|
||
_
|
||
=
|
||
'_'})),
|
||
lists:foreach(fun
|
||
(#pubsub_item{itemid
|
||
=
|
||
ItemId} =
|
||
Item) ->
|
||
{IID,
|
||
_} =
|
||
ItemId,
|
||
{M1,
|
||
M2} =
|
||
Item#pubsub_item.modification,
|
||
{C1,
|
||
C2} =
|
||
Item#pubsub_item.creation,
|
||
mnesia:delete({pubsub_item,
|
||
ItemId}),
|
||
mnesia:write(Item#pubsub_item{itemid
|
||
=
|
||
{IID,
|
||
NodeIdx},
|
||
modification
|
||
=
|
||
{M2,
|
||
M1},
|
||
creation
|
||
=
|
||
{C2,
|
||
C1}})
|
||
end,
|
||
mnesia:match_object(#pubsub_item{itemid
|
||
=
|
||
{'_',
|
||
NodeId},
|
||
_
|
||
=
|
||
'_'})),
|
||
NodeIdx + 1
|
||
end,
|
||
1,
|
||
mnesia:match_object({pubsub_node,
|
||
{Host, '_'},
|
||
'_', '_',
|
||
'_', '_',
|
||
'_'})
|
||
++
|
||
mnesia:match_object({pubsub_node,
|
||
{{'_',
|
||
ServerHost,
|
||
'_'},
|
||
'_'},
|
||
'_', '_',
|
||
'_', '_',
|
||
'_'})),
|
||
mnesia:write(#pubsub_index{index = node,
|
||
last = LastIdx, free = []})
|
||
end,
|
||
case mnesia:transaction(FNew) of
|
||
{atomic, Result} ->
|
||
rename_default_nodeplugin(),
|
||
?INFO_MSG("Pubsub nodes table upgraded: ~p",
|
||
[Result]);
|
||
{aborted, Reason} ->
|
||
?ERROR_MSG("Problem upgrading Pubsub nodes table:~n~p",
|
||
[Reason])
|
||
end;
|
||
[nodeid, id, parent, type, owners, options] ->
|
||
F = fun ({pubsub_node, NodeId, Id, Parent, Type, Owners,
|
||
Options}) ->
|
||
#pubsub_node{nodeid = NodeId, id = Id,
|
||
parents = [Parent], type = Type,
|
||
owners = Owners, options = Options}
|
||
end,
|
||
mnesia:transform_table(pubsub_node, F,
|
||
[nodeid, id, parents, type, owners, options]),
|
||
rename_default_nodeplugin();
|
||
_ -> ok
|
||
end,
|
||
convert_list_nodes().
|
||
|
||
rename_default_nodeplugin() ->
|
||
lists:foreach(fun (Node) ->
|
||
mnesia:dirty_write(Node#pubsub_node{type =
|
||
<<"hometree">>})
|
||
end,
|
||
mnesia:dirty_match_object(#pubsub_node{type =
|
||
<<"default">>,
|
||
_ = '_'})).
|
||
|
||
update_state_database(_Host, _ServerHost) ->
|
||
case catch mnesia:table_info(pubsub_state, attributes) of
|
||
[stateid, nodeidx, items, affiliation, subscriptions] ->
|
||
?INFO_MSG("Upgrading pubsub states table...", []),
|
||
F = fun ({pubsub_state, {{U,S,R}, NodeID}, _NodeIdx, Items, Aff, Sub}, Acc) ->
|
||
JID = {U,S,R},
|
||
Subs = case Sub of
|
||
none ->
|
||
[];
|
||
[] ->
|
||
[];
|
||
_ ->
|
||
SubID = pubsub_subscription:make_subid(),
|
||
[{Sub, SubID}]
|
||
end,
|
||
NewState = #pubsub_state{stateid = {JID, NodeID},
|
||
items = Items,
|
||
affiliation = Aff,
|
||
subscriptions = Subs},
|
||
[NewState | Acc]
|
||
end,
|
||
{atomic, NewRecs} = mnesia:transaction(fun mnesia:foldl/3,
|
||
[F, [], pubsub_state]),
|
||
{atomic, ok} = mnesia:delete_table(pubsub_state),
|
||
{atomic, ok} = ejabberd_mnesia:create(?MODULE, pubsub_state,
|
||
[{disc_copies, [node()]},
|
||
{attributes, record_info(fields, pubsub_state)}]),
|
||
FNew = fun () ->
|
||
lists:foreach(fun mnesia:write/1, NewRecs)
|
||
end,
|
||
case mnesia:transaction(FNew) of
|
||
{atomic, Result} ->
|
||
?INFO_MSG("Pubsub states table upgraded: ~p",
|
||
[Result]);
|
||
{aborted, Reason} ->
|
||
?ERROR_MSG("Problem upgrading Pubsub states table:~n~p",
|
||
[Reason])
|
||
end;
|
||
_ ->
|
||
ok
|
||
end,
|
||
convert_list_subscriptions(),
|
||
convert_list_states().
|
||
|
||
update_lastitem_database(_Host, _ServerHost) ->
|
||
convert_list_lasts().
|
||
|
||
%% binarization from old 2.1.x
|
||
|
||
convert_list_items() ->
|
||
convert_list_records(
|
||
pubsub_item,
|
||
record_info(fields, pubsub_item),
|
||
fun(#pubsub_item{itemid = {I, _}}) -> I end,
|
||
fun(#pubsub_item{itemid = {I, Nidx},
|
||
creation = {C, CKey},
|
||
modification = {M, MKey},
|
||
payload = Els} = R) ->
|
||
R#pubsub_item{itemid = {bin(I), Nidx},
|
||
creation = {C, binusr(CKey)},
|
||
modification = {M, binusr(MKey)},
|
||
payload = [fxml:to_xmlel(El) || El<-Els]}
|
||
end).
|
||
|
||
convert_list_states() ->
|
||
convert_list_records(
|
||
pubsub_state,
|
||
record_info(fields, pubsub_state),
|
||
fun(#pubsub_state{stateid = {{U,_,_}, _}}) -> U end,
|
||
fun(#pubsub_state{stateid = {U, Nidx},
|
||
items = Is,
|
||
affiliation = A,
|
||
subscriptions = Ss} = R) ->
|
||
R#pubsub_state{stateid = {binusr(U), Nidx},
|
||
items = [bin(I) || I<-Is],
|
||
affiliation = A,
|
||
subscriptions = [{S,bin(Sid)} || {S,Sid}<-Ss]}
|
||
end).
|
||
|
||
convert_list_nodes() ->
|
||
convert_list_records(
|
||
pubsub_node,
|
||
record_info(fields, pubsub_node),
|
||
fun(#pubsub_node{nodeid = {{U,_,_}, _}}) -> U;
|
||
(#pubsub_node{nodeid = {H, _}}) -> H end,
|
||
fun(#pubsub_node{nodeid = {H, N},
|
||
id = I,
|
||
parents = Ps,
|
||
type = T,
|
||
owners = Os,
|
||
options = Opts} = R) ->
|
||
R#pubsub_node{nodeid = {binhost(H), bin(N)},
|
||
id = I,
|
||
parents = [bin(P) || P<-Ps],
|
||
type = bin(T),
|
||
owners = [binusr(O) || O<-Os],
|
||
options = Opts}
|
||
end).
|
||
|
||
convert_list_subscriptions() ->
|
||
[convert_list_records(
|
||
pubsub_subscription,
|
||
record_info(fields, pubsub_subscription),
|
||
fun(#pubsub_subscription{subid = I}) -> I end,
|
||
fun(#pubsub_subscription{subid = I,
|
||
options = Opts} = R) ->
|
||
R#pubsub_subscription{subid = bin(I),
|
||
options = Opts}
|
||
end) || lists:member(pubsub_subscription, mnesia:system_info(tables))].
|
||
|
||
convert_list_lasts() ->
|
||
convert_list_records(
|
||
pubsub_last_item,
|
||
record_info(fields, pubsub_last_item),
|
||
fun(#pubsub_last_item{itemid = I}) -> I end,
|
||
fun(#pubsub_last_item{itemid = I,
|
||
nodeid = Nidx,
|
||
creation = {C, CKey},
|
||
payload = Payload} = R) ->
|
||
R#pubsub_last_item{itemid = bin(I),
|
||
nodeid = Nidx,
|
||
creation = {C, binusr(CKey)},
|
||
payload = fxml:to_xmlel(Payload)}
|
||
end).
|
||
|
||
%% internal tools
|
||
|
||
convert_list_records(Tab, Fields, DetectFun, ConvertFun) ->
|
||
case mnesia:table_info(Tab, attributes) of
|
||
Fields ->
|
||
ejabberd_config:convert_table_to_binary(
|
||
Tab, Fields, set, DetectFun, ConvertFun);
|
||
_ ->
|
||
?INFO_MSG("Recreating ~p table", [Tab]),
|
||
mnesia:transform_table(Tab, ignore, Fields),
|
||
convert_list_records(Tab, Fields, DetectFun, ConvertFun)
|
||
end.
|
||
|
||
binhost({U,S,R}) -> binusr({U,S,R});
|
||
binhost(L) -> bin(L).
|
||
|
||
binusr({U,S,R}) -> {bin(U), bin(S), bin(R)}.
|
||
|
||
bin(L) -> iolist_to_binary(L).
|
||
|