Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

Remove support for legacy user sessions (#4540)

Adrian Gruntkowskif7bbbf8c337c
diff --git a/lib/plausible_web/live/reset_password_form.ex b/lib/plausible_web/live/reset_password_form.ex
index 6b757d4ec0..7d60240360 100644
--- a/lib/plausible_web/live/reset_password_form.ex
+++ b/lib/plausible_web/live/reset_password_form.ex
@@ -10,6 +10,7 @@ defmodule PlausibleWeb.Live.ResetPasswordForm do
alias Plausible.Auth
alias Plausible.Repo
+ alias PlausibleWeb.UserAuth
def mount(_params, %{"email" => email}, socket) do
socket =
@@ -96,7 +97,8 @@ defmodule PlausibleWeb.Live.ResetPasswordForm do
end)
case result do
- {:ok, _user} ->
+ {:ok, user} ->
+ UserAuth.revoke_all_user_sessions(user)
{:noreply, assign(socket, trigger_submit: true)}
{:error, changeset} ->
diff --git a/lib/plausible_web/plugs/session_timeout_plug.ex b/lib/plausible_web/plugs/session_timeout_plug.ex
deleted file mode 100644
index 0add19b18b..0000000000
--- a/lib/plausible_web/plugs/session_timeout_plug.ex
+++ /dev/null
@@ -1,43 +0,0 @@
-defmodule PlausibleWeb.SessionTimeoutPlug do
- @moduledoc """
- NOTE: This plug will be replaced with a different
- session expiration mechanism once server-side persisted
- sessions are rolled out.
- """
- import Plug.Conn
-
- def init(opts \\ []) do
- opts
- end
-
- def call(conn, opts) do
- timeout_at = get_session(conn, :session_timeout_at)
- user_id = get_session(conn, :current_user_id)
-
- cond do
- user_id && timeout_at && now() > timeout_at ->
- conn
- |> PlausibleWeb.UserAuth.log_out_user()
- |> Phoenix.Controller.redirect(to: "/login")
- |> halt()
-
- user_id ->
- put_session(
- conn,
- :session_timeout_at,
- new_session_timeout_at(opts[:timeout_after_seconds])
- )
-
- true ->
- conn
- end
- end
-
- defp now do
- DateTime.utc_now() |> DateTime.to_unix()
- end
-
- defp new_session_timeout_at(timeout_after_seconds) do
- now() + timeout_after_seconds
- end
-end
diff --git a/lib/plausible_web/plugs/user_session_touch.ex b/lib/plausible_web/plugs/user_session_touch.ex
index 560b68be00..5802a0c231 100644
--- a/lib/plausible_web/plugs/user_session_touch.ex
+++ b/lib/plausible_web/plugs/user_session_touch.ex
@@ -12,9 +12,6 @@ defmodule PlausibleWeb.Plugs.UserSessionTouch do
end
def call(conn, _opts) do
- # NOTE: Needed only during transitional 14-day period
- conn = UserAuth.convert_legacy_session(conn)
-
if user_session = conn.assigns[:current_user_session] do
assign(
conn,
diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.ex
index fb601c259d..45b368e764 100644
--- a/lib/plausible_web/router.ex
+++ b/lib/plausible_web/router.ex
@@ -2,7 +2,6 @@ defmodule PlausibleWeb.Router do
use PlausibleWeb, :router
use Plausible
import Phoenix.LiveView.Router
- @two_weeks_in_seconds 60 * 60 * 24 * 14
pipeline :browser do
plug :accepts, ["html"]
@@ -11,7 +10,6 @@ defmodule PlausibleWeb.Router do
plug :put_secure_browser_headers
plug PlausibleWeb.Plugs.NoRobots
on_ee(do: nil, else: plug(PlausibleWeb.FirstLaunchPlug, redirect_to: "/register"))
- plug PlausibleWeb.SessionTimeoutPlug, timeout_after_seconds: @two_weeks_in_seconds
plug PlausibleWeb.AuthPlug
plug PlausibleWeb.Plugs.UserSessionTouch
end
diff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.ex
index c850b2c087..02cec2c645 100644
--- a/lib/plausible_web/user_auth.ex
+++ b/lib/plausible_web/user_auth.ex
@@ -1,15 +1,6 @@
defmodule PlausibleWeb.UserAuth do
@moduledoc """
Functions for user session management.
-
- In it's current shape, both current (legacy) and soon to be implemented (new)
- user sessions are supported side by side.
-
- The legacy token is still accepted from the session cookie. Once 14 days
- pass (the current time window for which session cookie is valid without
- any activity), the legacy cookies won't be accepted anymore (legacy token
- retrieval is tracked with logging) and the logic will be cleaned of branching
- for legacy session.
"""
import Ecto.Query, only: [from: 2]
@@ -61,12 +52,7 @@ defmodule PlausibleWeb.UserAuth do
end
end
- @spec touch_user_session(Auth.UserSession.t()) :: Auth.UserSession.t()
- def touch_user_session(%{token: nil} = user_session) do
- # NOTE: Legacy token sessions can't be touched.
- user_session
- end
-
+ @spec touch_user_session(Auth.UserSession.t(), NaiveDateTime.t()) :: Auth.UserSession.t()
def touch_user_session(user_session, now \\ NaiveDateTime.utc_now(:second)) do
if NaiveDateTime.diff(now, user_session.last_used_at, :hour) >= 1 do
Plausible.Users.bump_last_seen(user_session.user_id, now)
@@ -79,6 +65,18 @@ defmodule PlausibleWeb.UserAuth do
end
end
+ @spec revoke_all_user_sessions(Auth.User.t()) :: :ok
+ def revoke_all_user_sessions(user) do
+ {_count, tokens} =
+ Repo.delete_all(
+ from us in Auth.UserSession, where: us.user_id == ^user.id, select: us.token
+ )
+
+ Enum.each(tokens, fn token ->
+ PlausibleWeb.Endpoint.broadcast(live_socket_id(token), "disconnect", %{})
+ end)
+ end
+
@doc """
Sets the `logged_in` cookie share with the static site for determining
whether client is authenticated.
@@ -94,33 +92,7 @@ defmodule PlausibleWeb.UserAuth do
)
end
- @spec convert_legacy_session(Plug.Conn.t()) :: Plug.Conn.t()
- def convert_legacy_session(conn) do
- current_user = conn.assigns[:current_user]
-
- if current_user && Plug.Conn.get_session(conn, :current_user_id) do
- {token, user_session} = create_user_session(conn, current_user)
-
- conn
- |> put_token_in_session(token)
- |> Plug.Conn.delete_session(:current_user_id)
- |> Plug.Conn.assign(:current_user_session, user_session)
- else
- conn
- end
- end
-
- defp get_session_by_token({:legacy, user_id}) do
- case Plausible.Users.with_subscription(user_id) do
- %Auth.User{} = user ->
- {:ok, %Auth.UserSession{user_id: user.id, user: user}}
-
- nil ->
- {:error, :session_not_found}
- end
- end
-
- defp get_session_by_token({:new, token}) do
+ defp get_session_by_token(token) do
now = NaiveDateTime.utc_now(:second)
last_subscription_query = Plausible.Users.last_subscription_join_query()
@@ -165,10 +137,14 @@ defmodule PlausibleWeb.UserAuth do
Plug.Conn.delete_resp_cookie(conn, "logged_in")
end
- defp put_token_in_session(conn, {:new, token}) do
+ defp put_token_in_session(conn, token) do
conn
|> Plug.Conn.put_session(:user_token, token)
- |> Plug.Conn.put_session(:live_socket_id, "user_sessions:#{Base.url_encode64(token)}")
+ |> Plug.Conn.put_session(:live_socket_id, live_socket_id(token))
+ end
+
+ defp live_socket_id(token) do
+ "user_sessions:#{Base.url_encode64(token)}"
end
defp get_user_token(%Plug.Conn{} = conn) do
@@ -178,12 +154,7 @@ defmodule PlausibleWeb.UserAuth do
end
defp get_user_token(%{"user_token" => token}) when is_binary(token) do
- {:ok, {:new, token}}
- end
-
- defp get_user_token(%{"current_user_id" => user_id}) when is_integer(user_id) do
- Logger.warning("Legacy user session detected (user: #{user_id})")
- {:ok, {:legacy, user_id}}
+ {:ok, token}
end
defp get_user_token(_) do
@@ -198,12 +169,10 @@ defmodule PlausibleWeb.UserAuth do
|> Auth.UserSession.new_session(device_name)
|> Repo.insert!()
- {{:new, user_session.token}, user_session}
+ {user_session.token, user_session}
end
- defp remove_user_session({:legacy, _}), do: :ok
-
- defp remove_user_session({:new, token}) do
+ defp remove_user_session(token) do
Repo.delete_all(from us in Auth.UserSession, where: us.token == ^token)
:ok
end
diff --git a/test/plausible_web/live/reset_password_form_test.exs b/test/plausible_web/live/reset_password_form_test.exs
index 3acaedfc39..2f0f8f9d6f 100644
--- a/test/plausible_web/live/reset_password_form_test.exs
+++ b/test/plausible_web/live/reset_password_form_test.exs
@@ -1,6 +1,7 @@
defmodule PlausibleWeb.Live.ResetPasswordFormTest do
use PlausibleWeb.ConnCase, async: true
+ import Phoenix.ChannelTest
import Phoenix.LiveViewTest
import Plausible.Test.Support.HTML
@@ -60,6 +61,32 @@ defmodule PlausibleWeb.Live.ResetPasswordFormTest do
end
end
+ describe "/password/reset with logged in user" do
+ setup [:create_user, :log_in]
+
+ test "revokes all active user sessions when present", %{conn: conn, user: user} do
+ assert [active_session] = Repo.preload(user, :sessions).sessions
+ live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)
+ Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)
+
+ another_session =
+ user
+ |> Plausible.Auth.UserSession.new_session("Some Device")
+ |> Repo.insert!()
+
+ token = Token.sign_password_reset(user.email)
+
+ lv = get_liveview(conn, "/password/reset?token=#{token}")
+
+ type_into_passowrd(lv, "very-secret-and-very-long-123")
+ lv |> element("form") |> render_submit()
+
+ assert [] = Repo.preload(user, :sessions).sessions
+ assert_broadcast "disconnect", %{}
+ refute Repo.reload(another_session)
+ end
+ end
+
defp get_liveview(conn, url) do
conn = assign(conn, :live_module, PlausibleWeb.Live.ResetPasswordForm)
{:ok, lv, _html} = live(conn, url)
diff --git a/test/plausible_web/plugs/session_timeout_plug_test.exs b/test/plausible_web/plugs/session_timeout_plug_test.exs
deleted file mode 100644
index 8a95fc75b9..0000000000
--- a/test/plausible_web/plugs/session_timeout_plug_test.exs
+++ /dev/null
@@ -1,47 +0,0 @@
-defmodule PlausibleWeb.SessionTimeoutPlugTest do
- use Plausible.DataCase, async: true
- use Plug.Test
-
- import Plausible.Factory
-
- alias PlausibleWeb.SessionTimeoutPlug
-
- @opts %{timeout_after_seconds: 10}
-
- @moduletag :capture_log
-
- test "does nothing if user is not logged in" do
- conn =
- conn(:get, "/")
- |> init_test_session(%{})
- |> SessionTimeoutPlug.call(@opts)
-
- refute get_session(conn, :session_timeout_at)
- end
-
- test "sets session timeout if user is logged in" do
- user = insert(:user)
-
- conn =
- conn(:get, "/")
- |> init_test_session(%{current_user_id: user.id})
- |> SessionTimeoutPlug.call(@opts)
-
- timeout = get_session(conn, :session_timeout_at)
- now = DateTime.utc_now() |> DateTime.to_unix()
- assert timeout > now
- end
-
- test "logs user out if timeout passed" do
- user = insert(:user)
-
- conn =
- conn(:get, "/")
- |> init_test_session(%{current_user_id: user.id, session_timeout_at: 1})
- |> SessionTimeoutPlug.call(@opts)
-
- assert conn.private[:plug_session_info] == :renew
- assert conn.halted
- assert Phoenix.ConnTest.redirected_to(conn, 302) == "/login"
- end
-end
diff --git a/test/plausible_web/plugs/user_session_touch_test.exs b/test/plausible_web/plugs/user_session_touch_test.exs
index 085d7dc780..b28ab37552 100644
--- a/test/plausible_web/plugs/user_session_touch_test.exs
+++ b/test/plausible_web/plugs/user_session_touch_test.exs
@@ -7,8 +7,6 @@ defmodule PlausibleWeb.Plugs.UserSessionTouchTest do
setup [:create_user, :log_in]
- @moduletag :capture_log
-
test "refreshes session", %{conn: conn, user: user} do
now = NaiveDateTime.utc_now(:second)
one_day_ago = NaiveDateTime.shift(now, day: -1)
@@ -36,24 +34,6 @@ defmodule PlausibleWeb.Plugs.UserSessionTouchTest do
refute conn.halted
assert get_session(conn, :login_dest) == "/"
- refute get_session(conn, :current_user_id)
refute get_session(conn, :user_token)
end
-
- test "converts legacy session when present", %{user: user} do
- %{sessions: [other_session]} = Repo.preload(user, :sessions)
-
- conn =
- build_conn()
- |> init_session()
- |> put_session(:current_user_id, user.id)
- |> AuthPlug.call([])
- |> UserSessionTouch.call([])
-
- refute get_session(conn, :current_user_id)
- assert user_token = get_session(conn, :user_token)
- assert conn.assigns.current_user_session.id
- assert conn.assigns.current_user_session.id != other_session.id
- assert conn.assigns.current_user_session.token == user_token
- end
end
diff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exs
index a79c8ab0ad..60d0416e05 100644
--- a/test/plausible_web/user_auth_test.exs
+++ b/test/plausible_web/user_auth_test.exs
@@ -2,7 +2,7 @@ defmodule PlausibleWeb.UserAuthTest do
use PlausibleWeb.ConnCase, async: true
import Ecto.Query, only: [from: 2]
- import ExUnit.CaptureLog
+ import Phoenix.ChannelTest
alias Plausible.Auth
alias Plausible.Repo
@@ -10,8 +10,6 @@ defmodule PlausibleWeb.UserAuthTest do
alias PlausibleWeb.Router.Helpers, as: Routes
- @moduletag capture_log: true
-
describe "log_in_user/2,3" do
setup [:create_user]
@@ -86,7 +84,6 @@ defmodule PlausibleWeb.UserAuthTest do
assert another_session.token == another_session_token
assert conn.private[:plug_session_info] == :renew
assert conn.resp_cookies["logged_in"].max_age == 0
- assert get_session(conn, :current_user_id) == nil
assert get_session(conn, :login_dest) == nil
end
end
@@ -100,27 +97,22 @@ defmodule PlausibleWeb.UserAuthTest do
end
test "gets session from session data map", %{user: user} do
- user_id = user.id
%{sessions: [user_session]} = Repo.preload(user, :sessions)
assert {:ok, session_from_token} =
UserAuth.get_user_session(%{"user_token" => user_session.token})
assert session_from_token.id == user_session.id
-
- capture_log(fn ->
- assert {:ok, %Auth.UserSession{user_id: ^user_id, token: nil}} =
- UserAuth.get_user_session(%{"current_user_id" => user.id})
- end) =~ "Legacy user session detected"
end
test "returns error on invalid or missing session data" do
conn = init_session(build_conn())
assert {:error, :no_valid_token} = UserAuth.get_user_session(conn)
assert {:error, :no_valid_token} = UserAuth.get_user_session(%{})
+ assert {:error, :no_valid_token} = UserAuth.get_user_session(%{"current_user_id" => 123})
end
- test "returns error on missing session (new token scaffold; to be revised)", %{
+ test "returns error on missing session", %{
conn: conn,
user: user
} do
@@ -229,64 +221,37 @@ defmodule PlausibleWeb.UserAuthTest do
refute Repo.reload(user_session)
end
-
- test "skips refreshing legacy session", %{user: user} do
- user_session = %Auth.UserSession{user_id: user.id}
-
- assert UserAuth.touch_user_session(user_session) == user_session
- end
end
- describe "convert_legacy_session/1" do
+ describe "revoke_all_user_sessions/1" do
setup [:create_user, :log_in]
- test "does nothing when there's no authenticated session" do
- conn =
- build_conn()
- |> init_session()
- |> UserAuth.convert_legacy_session()
-
- refute get_session(conn, :user_token)
- refute get_session(conn, :live_socket_id)
- refute conn.assigns[:current_user_session]
+ test "deletes and disconnects all user's sessions", %{user: user} do
+ assert [active_session] = Repo.preload(user, :sessions).sessions
+ live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)
+ Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)
+
+ another_session =
+ user
+ |> Auth.UserSession.new_session("Some Device")
+ |> Repo.insert!()
+
+ unrelated_session =
+ insert(:user)
+ |> Auth.UserSession.new_session("Some Device")
+ |> Repo.insert!()
+
+ assert :ok = UserAuth.revoke_all_user_sessions(user)
+ assert [] = Repo.preload(user, :sessions).sessions
+ assert_broadcast "disconnect", %{}
+ refute Repo.reload(another_session)
+ assert Repo.reload(unrelated_session)
end
- test "does nothing when there's a new token-based session already", %{conn: conn, user: user} do
- %{sessions: [user_session]} = Repo.preload(user, :sessions)
+ test "executes gracefully when user has no sessions" do
+ user = insert(:user)
- conn =
- conn
- |> UserAuth.convert_legacy_session()
- |> PlausibleWeb.AuthPlug.call([])
-
- assert get_session(conn, :user_token) == user_session.token
-
- assert get_session(conn, :live_socket_id) ==
- "user_sessions:#{Base.url_encode64(user_session.token)}"
-
- assert conn.assigns.current_user_session.id == user_session.id
- end
-
- test "converts legacy session to a new one", %{user: user} do
- %{sessions: [existing_session]} = Repo.preload(user, :sessions)
-
- conn =
- build_conn()
- |> init_session()
- |> put_session(:current_user_id, user.id)
- |> PlausibleWeb.AuthPlug.call([])
- |> UserAuth.convert_legacy_session()
-
- assert conn.assigns.current_user_session.id
- assert conn.assigns.current_user_session.id != existing_session.id
- assert conn.assigns.current_user_session.token != existing_session.token
- assert conn.assigns.current_user_session.user_id == user.id
- assert conn.assigns.current_user.id == user.id
- refute get_session(conn, :current_user_id)
- assert get_session(conn, :user_token) == conn.assigns.current_user_session.token
-
- assert get_session(conn, :live_socket_id) ==
- "user_sessions:#{Base.url_encode64(conn.assigns.current_user_session.token)}"
+ assert :ok = UserAuth.revoke_all_user_sessions(user)
end
end