plugins/muc_ping.lua

-- XEP-0410: MUC Self-Ping

--

-- Detects silent MUC disconnects (e.g. a remote MUC service restarting

-- without us receiving an unavailable presence) by pinging our own

-- occupant JID in rooms we have received no traffic from for a while,

-- and rejoining when the ping shows we are no longer joined.

local verse = require "verse";

local jid = require "prosody.util.jid";

local xmlns_ping = "urn:xmpp:ping";

local xmlns_muc = "http://jabber.org/protocol/muc";

-- Ping error conditions that still mean we are joined (XEP-0410 §3.2)

local still_joined = {

	["service-unavailable"] = true;

	["feature-not-implemented"] = true;

};

-- Conditions meaning the MUC was unreachable, so joined-ness is unknown

local unreachable = {

	["remote-server-not-found"] = true;

	["remote-server-timeout"] = true;

	["timeout"] = true;

};

function riddim.plugins.muc_ping(bot)

	local stream = bot.stream;

	local interval = bot.config.muc_ping_interval or 300;

	local timeout = bot.config.muc_ping_timeout or 60;

	local serial = 0;

	-- Any stanza from a room is proof that we are still connected to it

	stream:hook("stanza", function (stanza)

		local room_jid = jid.bare(stanza.attr.from);

		local room = room_jid and stream.rooms[room_jid];

		if room then

			room.last_activity = os.time();

		end

	end, 1000);

	stream:hook("groupchat/joining", function (room)

		room.last_activity = os.time();

	end, 1000);

	local function rejoin(room, forget_occupants)

		if forget_occupants then

			-- The room's presence handler keeps a reference to this table,

			-- so it must be cleared in place, not replaced

			for nick in pairs(room.occupants) do

				room.occupants[nick] = nil;

			end

		end

		local join_st = verse.presence():tag("x", { xmlns = xmlns_muc }):reset();

		stream:event("pre-groupchat/joining", join_st);

		room:send(join_st);

	end

	local function ping_room(room)

		serial = serial + 1;

		local this_ping = serial;

		room.pending_ping = this_ping;

		local function result(ok, condition)

			if room.pending_ping ~= this_ping then return; end

			room.pending_ping = nil;

			room.last_activity = os.time();

			if stream.rooms[room.jid] ~= room then return; end -- room was left

			if ok or still_joined[condition] then

				return;

			elseif unreachable[condition] then

				-- Try joining in case we were dropped (harmless if we are

				-- still an occupant), and keep pinging

				stream:warn("muc_ping: no response from %s (%s), rejoining", room.jid, condition);

				rejoin(room, false);

			else -- e.g. not-acceptable, item-not-found: we are not joined

				stream:warn("muc_ping: not in %s (%s), rejoining", room.jid, condition);

				rejoin(room, true);

			end

		end

		stream:debug("muc_ping: pinging %s", room.jid);

		stream:send_iq(verse.iq({ to = room.jid.."/"..room.nick, type = "get" })

			:tag("ping", { xmlns = xmlns_ping }), function (reply)

				if reply.attr.type == "error" then

					local _, condition = reply:get_error();

					result(false, condition or "undefined-condition");

				else

					result(true);

				end

			end);

		verse.add_task(timeout, function ()

			result(false, "timeout");

		end);

	end

	verse.add_task(interval, function ()

		local now = os.time();

		for _, room in pairs(stream.rooms) do

			if not room.pending_ping and now - (room.last_activity or now) >= interval then

				ping_room(room);

			end

			if not room.last_activity then

				room.last_activity = now;

			end

		end

		return interval;

	end);

end