A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(gateway): send events to visitors, evict on access change
Hampusa104172b8a01
diff --git a/fluxer_gateway/src/guild/guild_visitor_dispatch.erl b/fluxer_gateway/src/guild/guild_visitor_dispatch.erlnew file mode 100644index 000000000..b43c5f27e--- /dev/null+++ b/fluxer_gateway/src/guild/guild_visitor_dispatch.erl@@ -0,0 +1,383 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_visitor_dispatch).+-typing([eqwalizer]).++-export([+ after_dispatch/4,+ channel_visible/3+]).++-define(GUILD_VIEW_EVENTS, [+ guild_update,+ guild_role_create,+ guild_role_update,+ guild_role_update_bulk,+ guild_role_delete+]).+-define(GUILD_EVENTS, ?GUILD_VIEW_EVENTS ++ [guild_emojis_update, guild_stickers_update]).+-define(CHANNEL_EVENTS, [channel_create, channel_update, channel_update_bulk, channel_delete]).+-define(FOCUSED_EVENTS, [+ message_create,+ message_update,+ message_delete,+ message_delete_bulk,+ message_reaction_add,+ message_reaction_remove,+ message_reaction_remove_all,+ message_reaction_remove_emoji+]).+-define(THREAD_EVENTS, [thread_create, thread_update, thread_delete]).+-define(VIEW_EVENTS, ?GUILD_VIEW_EVENTS ++ ?CHANNEL_EVENTS).++-type guild_state() :: map().+-type session() :: guild_visitors:visitor_session().+-type delivery() :: {atom(), pid(), map()}.++-spec allowed(atom()) -> boolean().+allowed(Event) ->+ scope(Event) =/= none.++-spec visitor_payload(atom(), map()) -> map().+visitor_payload(Event, Data) when+ Event =:= message_reaction_add; Event =:= message_reaction_remove+->+ maps:without([<<"user_id">>, <<"member">>, <<"session_id">>], Data);+visitor_payload(Event, Data) when+ Event =:= channel_create; Event =:= channel_update; Event =:= channel_delete+->+ strip_channel(Data);+visitor_payload(channel_update_bulk, #{<<"channels">> := Channels} = Data) when+ is_list(Channels)+->+ Data#{<<"channels">> => [strip_channel(C) || C <- Channels, is_map(C)]};+visitor_payload(Event, Data) when Event =:= thread_create; Event =:= thread_update ->+ maps:without([<<"member">>, <<"member_ids_preview">>], Data);+visitor_payload(thread_delete, Data) ->+ maps:with([<<"id">>, <<"guild_id">>, <<"parent_id">>, <<"type">>], Data);+visitor_payload(_Event, Data) ->+ Data.++-spec strip_channel(map()) -> map().+strip_channel(Channel) ->+ case snowflake_id:parse_maybe(maps:get(<<"guild_id">>, Channel, undefined)) of+ GuildId when is_integer(GuildId) ->+ guild_visitor_permissions:strip_overwrites(Channel, GuildId);+ _ ->+ Channel#{<<"permission_overwrites">> => []}+ end.++-spec after_dispatch(atom(), map(), map(), map()) -> map().+after_dispatch(guild_member_add, Data, _OldState, State) ->+ guild_visitors:promote_user(member_user_id(Data), State);+after_dispatch(Event, Data, OldState, State) ->+ case guild_visitors:count(State) of+ 0 -> State;+ _ -> visitor_dispatch(Event, Data, OldState, State)+ end.++-spec visitor_dispatch(atom(), map(), guild_state(), guild_state()) -> guild_state().+visitor_dispatch(guild_delete, _Data, _OldState, State) ->+ guild_visitors:evict_all(removed, State);+visitor_dispatch(Event, Data0, OldState, State0) ->+ GuildId = maps:get(id, State0),+ Data = (guild_thread_payload:strip_internal(Data0))#{+ <<"guild_id">> => integer_to_binary(GuildId)+ },+ State1 =+ case Event of+ guild_update -> guild_visitors:evict_minors(guild_visitors:evict_disabled(State0));+ _ -> State0+ end,+ {ViewDeliveries, State2} = refresh_for(Event, Data, OldState, State1),+ Deliveries =+ case allowed(Event) of+ true -> event_deliveries(Event, Data, State2);+ false -> []+ end,+ ok = deliver(ViewDeliveries ++ Deliveries, State2),+ State2.++-spec refresh_for(atom(), map(), guild_state(), guild_state()) -> {[delivery()], guild_state()}.+refresh_for(Event, Data, OldState, State) ->+ case lists:member(Event, ?VIEW_EVENTS) of+ false ->+ {[], State};+ true ->+ Before = guild_visitors:sessions(State),+ State1 = guild_visitors:refresh_views(State),+ After = guild_visitors:sessions(State1),+ {view_deliveries(Event, Data, Before, After, OldState, State1), State1}+ end.++-spec view_deliveries(atom(), map(), map(), map(), guild_state(), guild_state()) ->+ [delivery()].+view_deliveries(Event, Data, Before, After, OldState, State) ->+ EventIds = event_channel_ids(Event, Data),+ OldIndex = channel_index(OldState),+ NewIndex = channel_index(State),+ GuildId = maps:get(id, State),+ Context = #{+ event => Event,+ data => Data,+ before => Before,+ event_ids => EventIds,+ old_index => OldIndex,+ new_index => NewIndex,+ guild_id => GuildId,+ state => State+ },+ maps:fold(+ fun(SessionId, Session, Acc) ->+ session_view_deliveries(SessionId, Session, Context) ++ Acc+ end,+ [],+ After+ ).++-spec session_view_deliveries(binary(), session(), map()) -> [delivery()].+session_view_deliveries(SessionId, #{pid := Pid, viewable_channels := New} = Session, #{+ event := Event,+ data := Data,+ before := Before,+ event_ids := EventIds,+ old_index := OldIndex,+ new_index := NewIndex,+ guild_id := GuildId,+ state := State+}) ->+ Old =+ case maps:get(SessionId, Before, undefined) of+ #{viewable_channels := View} -> View;+ _ -> New+ end,+ Lost = [Id || Id <- maps:keys(Old), not maps:is_key(Id, New)],+ Gained = [Id || Id <- maps:keys(New), not maps:is_key(Id, Old)],+ Deletes = [+ {channel_delete, Pid, lost_payload(Event, Id, Data, OldIndex, GuildId)}+ || Id <- Lost+ ],+ ChangesChannels = lists:member(Event, [channel_create, channel_update, channel_update_bulk]),+ Creates = [+ {channel_create, Pid,+ mask_for(+ Session, channel_create, strip_channel(with_guild(Channel, GuildId)), State+ )}+ || Id <- Gained,+ not (ChangesChannels andalso lists:member(Id, EventIds)),+ Channel <- [maps:get(Id, NewIndex, undefined)],+ is_map(Channel)+ ],+ Deletes ++ Creates.++-spec lost_payload(atom(), integer(), map(), map(), integer()) -> map().+lost_payload(channel_delete, Id, Data, OldIndex, GuildId) ->+ case snowflake_id:parse_maybe(maps:get(<<"id">>, Data, undefined)) of+ Id -> visitor_payload(channel_delete, Data);+ _ -> minimal_delete(Id, OldIndex, GuildId)+ end;+lost_payload(_Event, Id, _Data, OldIndex, GuildId) ->+ minimal_delete(Id, OldIndex, GuildId).++-spec minimal_delete(integer(), map(), integer()) -> map().+minimal_delete(Id, OldIndex, GuildId) ->+ Base = #{<<"id">> => integer_to_binary(Id), <<"guild_id">> => integer_to_binary(GuildId)},+ case maps:get(Id, OldIndex, undefined) of+ #{<<"type">> := Type} = Channel ->+ maps:merge(Base#{<<"type">> => Type}, maps:with([<<"parent_id">>], Channel));+ _ ->+ Base+ end.++-spec with_guild(map(), integer()) -> map().+with_guild(Channel, GuildId) ->+ Channel#{<<"guild_id">> => integer_to_binary(GuildId)}.++-spec event_channel_ids(atom(), map()) -> [integer()].+event_channel_ids(channel_update_bulk, #{<<"channels">> := Channels}) when is_list(Channels) ->+ [Id || C <- Channels, is_map(C), Id <- [channel_id(C)], is_integer(Id)];+event_channel_ids(Event, Data) when+ Event =:= channel_create; Event =:= channel_update; Event =:= channel_delete+->+ case channel_id(Data) of+ Id when is_integer(Id) -> [Id];+ _ -> []+ end;+event_channel_ids(_Event, _Data) ->+ [].++-spec event_deliveries(atom(), map(), guild_state()) -> [delivery()].+event_deliveries(Event, Data, State) ->+ Payload = visitor_payload(Event, Data),+ case scope(Event) of+ focused ->+ focused_deliveries(Event, Payload, Data, State);+ Scope ->+ scoped_deliveries(Scope, Event, Payload, Data, State)+ end.++-spec focused_deliveries(atom(), map(), map(), guild_state()) -> [delivery()].+focused_deliveries(Event, Payload, Data, State) ->+ case snowflake_id:parse_maybe(maps:get(<<"channel_id">>, Data, undefined)) of+ ChannelId when is_integer(ChannelId) ->+ [+ {Event, Pid, mask_for(S, Event, Payload, State)}+ || #{pid := Pid} = S <- guild_visitors:focused_sessions(ChannelId, State),+ channel_visible(S, ChannelId, State)+ ];+ _ ->+ []+ end.++-spec scoped_deliveries(+ guild | channel | pins | thread | none, atom(), map(), map(), guild_state()+) ->+ [delivery()].+scoped_deliveries(Scope, Event, Payload, Data, State) ->+ Sessions = maps:values(guild_visitors:sessions(State)),+ case Scope of+ guild ->+ [{Event, Pid, mask_for(S, Event, Payload, State)} || #{pid := Pid} = S <- Sessions];+ channel ->+ channel_deliveries(Event, Payload, Sessions, State);+ pins ->+ ChannelId = snowflake_id:parse_maybe(maps:get(<<"channel_id">>, Data, undefined)),+ [+ {Event, Pid, Payload}+ || #{pid := Pid} = S <- Sessions,+ is_integer(ChannelId),+ channel_visible(S, ChannelId, State)+ ];+ thread ->+ [+ {Event, Pid, Payload}+ || #{pid := Pid} = S <- Sessions,+ thread_visible(S, Data, State)+ ];+ none ->+ []+ end.++-spec channel_deliveries(atom(), map(), [session()], guild_state()) -> [delivery()].+channel_deliveries(channel_delete, _Payload, _Sessions, _State) ->+ [];+channel_deliveries(+ channel_update_bulk, #{<<"channels">> := Channels} = Payload, Sessions, State+) ->+ lists:filtermap(+ fun(Session) -> bulk_channel_delivery(Session, Channels, Payload, State) end,+ Sessions+ );+channel_deliveries(Event, Payload, Sessions, State) ->+ ChannelId = channel_id(Payload),+ [+ {Event, Pid, mask_for(S, Event, Payload, State)}+ || #{pid := Pid, viewable_channels := View} = S <- Sessions,+ is_integer(ChannelId),+ maps:is_key(ChannelId, View)+ ].++-spec bulk_channel_delivery(session(), [map()], map(), guild_state()) ->+ false | {true, delivery()}.+bulk_channel_delivery(+ #{pid := Pid, viewable_channels := View} = Session, Channels, Payload, State+) ->+ case [C || C <- Channels, is_map(C), maps:is_key(channel_id(C), View)] of+ [] ->+ false;+ Visible ->+ {true,+ {channel_update_bulk, Pid,+ mask_for(+ Session, channel_update_bulk, Payload#{<<"channels">> => Visible}, State+ )}}+ end.++-spec scope(atom()) -> guild | channel | focused | pins | thread | none.+scope(Event) ->+ case+ {+ lists:member(Event, ?GUILD_EVENTS),+ lists:member(Event, ?CHANNEL_EVENTS),+ lists:member(Event, ?FOCUSED_EVENTS),+ lists:member(Event, ?THREAD_EVENTS)+ }+ of+ {true, _, _, _} -> guild;+ {_, true, _, _} -> channel;+ {_, _, true, _} -> focused;+ {_, _, _, true} -> thread;+ _ when Event =:= channel_pins_update -> pins;+ _ -> none+ end.++-spec mask_for(session(), atom(), map(), guild_state()) -> map().+mask_for(#{thread_viewer := true}, _Event, Payload, _State) ->+ Payload;+mask_for(_Session, Event, Payload, State) ->+ case guild_thread_gate:needs_variant(State) of+ true -> guild_thread_payload:mask_payload(Event, Payload);+ false -> Payload+ end.++-spec channel_visible(guild_visitors:visitor_session(), integer(), map()) -> boolean().+channel_visible(#{viewable_channels := View} = Session, ChannelId, State) ->+ maps:is_key(ChannelId, View) orelse+ case guild_thread_gate:thread(ChannelId, State) of+ Thread when is_map(Thread) -> thread_visible(Session, Thread, State);+ _ -> false+ end.++-spec thread_visible(session(), map(), guild_state()) -> boolean().+thread_visible(#{viewable_channels := View} = Session, Thread, State) ->+ Viewer = maps:get(thread_viewer, Session, false) orelse not guild_thread_gate:active(State),+ PublicThread =+ Viewer andalso+ channel_types:is_public_thread(+ map_utils:get_integer(Thread, <<"type">>, undefined)+ ),+ PublicThread andalso+ maps:is_key(+ snowflake_id:parse_maybe(maps:get(<<"parent_id">>, Thread, undefined)), View+ ).++-spec deliver([delivery()], guild_state()) -> ok.+deliver([], _State) ->+ ok;+deliver(Deliveries, State) ->+ GuildId = maps:get(id, State),+ Grouped = lists:foldl(+ fun({Event, Pid, Payload}, Acc) ->+ Key = {Event, Payload},+ Acc#{Key => [Pid | maps:get(Key, Acc, [])]}+ end,+ #{},+ Deliveries+ ),+ maps:foreach(+ fun({Event, Payload}, Pids) ->+ Encoded =+ {pre_encoded,+ iolist_to_binary(+ json:encode(guild_data_wire:payload(Payload), fun json:encode_value/2)+ )},+ gateway_dispatch_relay:dispatch_many(lists:reverse(Pids), Event, Encoded, GuildId)+ end,+ Grouped+ ).++-spec channel_index(guild_state()) -> map().+channel_index(State) ->+ guild_data_index_channels:channel_index(guild_data_index:ensure_data_map(State)).++-spec channel_id(map()) -> integer() | undefined.+channel_id(Channel) ->+ snowflake_id:parse_maybe(maps:get(<<"id">>, Channel, undefined)).++-spec member_user_id(map()) -> integer() | undefined.+member_user_id(#{<<"user">> := #{<<"id">> := Id}}) ->+ snowflake_id:parse_maybe(Id);+member_user_id(#{<<"user_id">> := Id}) ->+ snowflake_id:parse_maybe(Id);+member_user_id(_) ->+ undefined.