From 3a2e78af9ff4cd0248582644d9900b164d17ffd2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Valim?= Date: Fri, 7 Feb 2025 18:21:09 +0100 Subject: [PATCH] Fix warnings on Elixir v1.19+ --- lib/flame/code_sync.ex | 8 ++++---- lib/flame/fly_backend.ex | 21 +++++++++---------- lib/flame/pool.ex | 44 +++++++++++++++++++--------------------- lib/flame/queue.ex | 6 +++--- lib/flame/runner.ex | 8 ++++---- lib/flame/terminator.ex | 28 ++++++++++++------------- 6 files changed, 56 insertions(+), 59 deletions(-) diff --git a/lib/flame/code_sync.ex b/lib/flame/code_sync.ex index bccb301..1c6029e 100644 --- a/lib/flame/code_sync.ex +++ b/lib/flame/code_sync.ex @@ -82,7 +82,7 @@ defmodule FLAME.CodeSync do apps end - %CodeSync{code | apps_to_start: apps_to_start} + %{code | apps_to_start: apps_to_start} end def compute_sync_beams(%CodeSync{} = code) do @@ -93,7 +93,7 @@ defmodule FLAME.CodeSync do into: %{}, do: {path, :erlang.md5(File.read!(path))} - %CodeSync{ + %{ code | sync_beam_hashes: beam_hashes, changed_paths: Enum.uniq(code.changed_paths ++ sync_beams_files) @@ -124,7 +124,7 @@ defmodule FLAME.CodeSync do lookup_apps_files(code) end - %CodeSync{code | changed_paths: Enum.uniq(code.changed_paths ++ changed_paths)} + %{code | changed_paths: Enum.uniq(code.changed_paths ++ changed_paths)} end def changed?(%CodeSync{} = code) do @@ -153,7 +153,7 @@ defmodule FLAME.CodeSync do for path <- deleted_paths, do: path |> Path.basename(".beam") |> String.to_atom() - %CodeSync{ + %{ current | changed_paths: changed, deleted_paths: deleted_paths, diff --git a/lib/flame/fly_backend.ex b/lib/flame/fly_backend.ex index ba87d14..52c57c2 100644 --- a/lib/flame/fly_backend.ex +++ b/lib/flame/fly_backend.ex @@ -191,7 +191,7 @@ defmodule FLAME.FlyBackend do end end - state = %FlyBackend{state | runner_node_base: "#{state.app}-flame-#{rand_id(20)}"} + state = %{state | runner_node_base: "#{state.app}-flame-#{rand_id(20)}"} parent_ref = make_ref() encoded_parent = @@ -217,8 +217,7 @@ defmodule FLAME.FlyBackend do end end) - new_state = - %FlyBackend{state | env: new_env, parent_ref: parent_ref, local_ip: ip} + new_state = %{state | env: new_env, parent_ref: parent_ref, local_ip: ip} {:ok, new_state} end @@ -286,19 +285,19 @@ defmodule FLAME.FlyBackend do ) end) - if state.log, - do: - Logger.log( - state.log, - "#{inspect(__MODULE__)} #{inspect(node())} machine create #{req_connect_time}ms" - ) + if state.log do + Logger.log( + state.log, + "#{inspect(__MODULE__)} #{inspect(node())} machine create #{req_connect_time}ms" + ) + end remaining_connect_window = state.boot_timeout - req_connect_time case resp do %{"id" => id, "instance_id" => instance_id, "private_ip" => ip} -> new_state = - %FlyBackend{ + %{ state | runner_id: id, runner_instance_id: instance_id, @@ -315,7 +314,7 @@ defmodule FLAME.FlyBackend do exit(:timeout) end - new_state = %FlyBackend{ + new_state = %{ new_state | remote_terminator_pid: remote_terminator_pid, runner_node_name: node(remote_terminator_pid) diff --git a/lib/flame/pool.ex b/lib/flame/pool.ex index ee84876..02ee7ca 100644 --- a/lib/flame/pool.ex +++ b/lib/flame/pool.ex @@ -488,7 +488,7 @@ defmodule FLAME.Pool do end def handle_info(:async_boot_continue, %Pool{} = state) do - {:noreply, async_boot_runner(%Pool{state | async_boot_timer: nil})} + {:noreply, async_boot_runner(%{state | async_boot_timer: nil})} end def handle_info({:cancel, ref, caller_pid, reason}, state) do @@ -567,7 +567,7 @@ defmodule FLAME.Pool do |> Map.delete(caller_pid) |> Map.put(child_pid, new_caller) - %Pool{state | callers: new_callers} + %{state | callers: new_callers} end defp checkin_runner(state, ref, caller_pid, reason) @@ -630,7 +630,7 @@ defmodule FLAME.Pool do runner_ref: runner.monitor_ref } - new_state = %Pool{state | callers: Map.put(state.callers, from_pid, new_caller)} + new_state = %{state | callers: Map.put(state.callers, from_pid, new_caller)} inc_runner_count(new_state, runner.monitor_ref) end @@ -638,7 +638,7 @@ defmodule FLAME.Pool do defp waiting_in(%Pool{} = state, deadline, {pid, _tag} = from) do ref = Process.monitor(pid) waiting = %WaitingState{from: from, monitor_ref: ref, deadline: deadline} - %Pool{state | waiting: Queue.insert(state.waiting, waiting, pid)} + %{state | waiting: Queue.insert(state.waiting, waiting, pid)} end defp boot_runners(%Pool{} = state) do @@ -667,11 +667,8 @@ defmodule FLAME.Pool do defp schedule_async_boot_runner(%Pool{} = state) do if state.async_boot_timer, do: Process.cancel_timer(state.async_boot_timer) - - %Pool{ - state - | async_boot_timer: Process.send_after(self(), :async_boot_continue, @async_boot_debounce) - } + timer = Process.send_after(self(), :async_boot_continue, @async_boot_debounce) + %{state | async_boot_timer: timer} end defp async_boot_runner(%Pool{on_grow_start: on_grow_start, name: name} = state) do @@ -685,7 +682,7 @@ defmodule FLAME.Pool do end) new_pending = Map.put(state.pending_runners, task.ref, task.pid) - %Pool{state | pending_runners: new_pending} + %{state | pending_runners: new_pending} end defp start_child_runner(%Pool{} = state, runner_opts \\ []) do @@ -713,48 +710,49 @@ defmodule FLAME.Pool do defp put_runner(%Pool{} = state, pid) when is_pid(pid) do ref = Process.monitor(pid) runner = %RunnerState{count: 0, pid: pid, monitor_ref: ref} - new_state = %Pool{state | runners: Map.put(state.runners, runner.monitor_ref, runner)} + new_state = %{state | runners: Map.put(state.runners, runner.monitor_ref, runner)} {runner, new_state} end defp inc_runner_count(%Pool{} = state, ref) do new_runners = Map.update!(state.runners, ref, fn %RunnerState{} = runner -> - %RunnerState{runner | count: runner.count + 1} + %{runner | count: runner.count + 1} end) - %Pool{state | runners: new_runners} + %{state | runners: new_runners} end defp dec_runner_count(%Pool{} = state, ref) do new_runners = Map.update!(state.runners, ref, fn %RunnerState{} = runner -> - %RunnerState{runner | count: runner.count - 1} + %{runner | count: runner.count - 1} end) - %Pool{state | runners: new_runners} + %{state | runners: new_runners} end defp drop_child_runner(%Pool{} = state, runner_ref) when is_reference(runner_ref) do %{^runner_ref => %RunnerState{}} = state.runners Process.demonitor(runner_ref, [:flush]) + # kill all callers that still had a checkout for this runner new_state = Enum.reduce(state.callers, state, fn {caller_pid, %Caller{monitor_ref: ref, runner_ref: ^runner_ref}}, acc -> Process.demonitor(ref, [:flush]) Process.exit(caller_pid, :kill) - %Pool{acc | callers: Map.delete(acc.callers, caller_pid)} + %{acc | callers: Map.delete(acc.callers, caller_pid)} {_caller_pid, %Caller{}}, acc -> acc end) - maybe_on_shrink(%Pool{new_state | runners: Map.delete(new_state.runners, runner_ref)}) + maybe_on_shrink(%{new_state | runners: Map.delete(new_state.runners, runner_ref)}) end defp drop_caller(%Pool{} = state, caller_pid, %Caller{} = caller) when is_pid(caller_pid) do - new_state = %Pool{state | callers: Map.delete(state.callers, caller_pid)} + new_state = %{state | callers: Map.delete(state.callers, caller_pid)} new_state |> dec_runner_count(caller.runner_ref) @@ -762,7 +760,7 @@ defmodule FLAME.Pool do end defp maybe_drop_waiting(%Pool{} = state, caller_pid) when is_pid(caller_pid) do - %Pool{state | waiting: Queue.delete_by_key(state.waiting, caller_pid)} + %{state | waiting: Queue.delete_by_key(state.waiting, caller_pid)} end defp pop_next_waiting_caller(%Pool{} = state) do @@ -780,8 +778,8 @@ defmodule FLAME.Pool do end) case result do - {nil, %Queue{} = new_waiting} -> {nil, %Pool{state | waiting: new_waiting}} - {{_pid, %WaitingState{} = first}, %Queue{} = rest} -> {first, %Pool{state | waiting: rest}} + {nil, %Queue{} = new_waiting} -> {nil, %{state | waiting: new_waiting}} + {{_pid, %WaitingState{} = first}, %Queue{} = rest} -> {first, %{state | waiting: rest}} end end @@ -816,7 +814,7 @@ defmodule FLAME.Pool do case state.pending_runners do %{^ref => _} -> - state = %Pool{state | pending_runners: Map.delete(state.pending_runners, ref)} + state = %{state | pending_runners: Map.delete(state.pending_runners, ref)} # we rate limit this to avoid many failed async boot attempts if has_unmet_servicable_demand?(state) do state @@ -859,7 +857,7 @@ defmodule FLAME.Pool do %{^ref => task_pid} = state.pending_runners Process.demonitor(ref, [:flush]) - new_state = %Pool{state | pending_runners: Map.delete(state.pending_runners, ref)} + new_state = %{state | pending_runners: Map.delete(state.pending_runners, ref)} {runner, new_state} = put_runner(new_state, pid) new_state = maybe_on_grow_end(new_state, task_pid, :ok) diff --git a/lib/flame/queue.ex b/lib/flame/queue.ex index 33aeb57..c157ab8 100644 --- a/lib/flame/queue.ex +++ b/lib/flame/queue.ex @@ -22,7 +22,7 @@ defmodule FLAME.Queue do def insert(%Queue{idx: idx} = queue, item, key) do new_tree = :gb_trees.insert(idx, {key, item}, queue.tree) new_keys = Map.put(queue.keys, key, idx) - %Queue{queue | tree: new_tree, keys: new_keys, idx: idx + 1} + %{queue | tree: new_tree, keys: new_keys, idx: idx + 1} end @doc """ @@ -41,7 +41,7 @@ defmodule FLAME.Queue do {_smallest_idx, {key, val}, new_tree} = :gb_trees.take_smallest(tree) new_keys = Map.delete(keys, key) new_idx = if :gb_trees.is_empty(new_tree), do: 0, else: idx - {{key, val}, %Queue{queue | tree: new_tree, keys: new_keys, idx: new_idx}} + {{key, val}, %{queue | tree: new_tree, keys: new_keys, idx: new_idx}} else {nil, queue} end @@ -103,7 +103,7 @@ defmodule FLAME.Queue do new_tree = :gb_trees.delete_any(index, tree) new_keys = Map.delete(keys, key) new_idx = if :gb_trees.is_empty(new_tree), do: 0, else: queue.idx - %Queue{queue | tree: new_tree, keys: new_keys, idx: new_idx} + %{queue | tree: new_tree, keys: new_keys, idx: new_idx} %{} -> queue diff --git a/lib/flame/runner.ex b/lib/flame/runner.ex index 2466590..958f5f8 100644 --- a/lib/flame/runner.ex +++ b/lib/flame/runner.ex @@ -294,7 +294,7 @@ defmodule FLAME.Runner do case runner.backend.remote_boot(backend_state) do {:ok, remote_terminator_pid, new_backend_state} when is_pid(remote_terminator_pid) -> Process.monitor(remote_terminator_pid) - new_runner = %Runner{runner | terminator: remote_terminator_pid, status: :booted} + new_runner = %{runner | terminator: remote_terminator_pid, status: :booted} new_state = %{state | runner: new_runner, backend_state: new_backend_state} {new_state, beams_stream} = maybe_stream_code_paths(new_state) @@ -403,7 +403,7 @@ defmodule FLAME.Runner do {backend, backend.init(Keyword.merge(base_backend_opts, backend_opts))} end - %Runner{runner | backend: backend, backend_init: backend_init} + %{runner | backend: backend, backend_init: backend_init} end defp time(%Runner{log: false} = _runner, _label, func) do @@ -525,7 +525,7 @@ defmodule FLAME.Runner do |> CodeSync.compute_sync_beams() %CodeSync.PackagedStream{} = parent_stream = CodeSync.package_to_stream(code_sync) - new_runner = %Runner{runner | code_sync: code_sync} + new_runner = %{runner | code_sync: code_sync} {%{state | runner: new_runner}, parent_stream} else {state, nil} @@ -535,7 +535,7 @@ defmodule FLAME.Runner do defp maybe_diff_code_paths(%{runner: %Runner{} = runner} = state) do if runner.code_sync do diffed_code = CodeSync.diff(runner.code_sync) - new_runner = %Runner{runner | code_sync: diffed_code} + new_runner = %{runner | code_sync: diffed_code} new_state = %{state | runner: new_runner} if CodeSync.changed?(diffed_code) do diff --git a/lib/flame/terminator.ex b/lib/flame/terminator.ex index 3871123..6f37165 100644 --- a/lib/flame/terminator.ex +++ b/lib/flame/terminator.ex @@ -251,10 +251,10 @@ defmodule FLAME.Terminator do new_state = new_state |> update_caller(child_ref, fn child -> - %Caller{child | placed_caller_ref: caller_ref, link?: link?} + %{child | placed_caller_ref: caller_ref, link?: link?} end) |> update_caller(caller_ref, fn caller -> - %Caller{caller | placed_child_ref: child_ref, link?: link?} + %{caller | placed_child_ref: child_ref, link?: link?} end) {:reply, {:ok, child_pid}, new_state} @@ -287,7 +287,7 @@ defmodule FLAME.Terminator do _from, %Terminator{} = state ) do - new_state = %Terminator{ + new_state = %{ state | single_use: single_use?, idle_shutdown_after: idle_after, @@ -328,7 +328,7 @@ defmodule FLAME.Terminator do defp update_caller(%Terminator{} = state, ref, func) when is_reference(ref) and is_function(func, 1) do - %Terminator{state | calls: Map.update!(state.calls, ref, func)} + %{state | calls: Map.update!(state.calls, ref, func)} end defp deadline_caller(%Terminator{} = state, from_pid, timeout) @@ -343,14 +343,14 @@ defmodule FLAME.Terminator do end caller = %Caller{from_pid: from_pid, timer: timer} - new_state = %Terminator{state | calls: Map.put(state.calls, ref, caller)} + new_state = %{state | calls: Map.put(state.calls, ref, caller)} {ref, cancel_idle_shutdown(new_state)} end defp drop_caller(%Terminator{} = state, ref) when is_reference(ref) do %{^ref => %Caller{} = caller} = state.calls if caller.timer, do: Process.cancel_timer(caller.timer) - state = %Terminator{state | calls: Map.delete(state.calls, ref)} + state = %{state | calls: Map.delete(state.calls, ref)} # if the caller going down was one that placed a child, and the child is still tracked: # - if the child is not linked (link: false), do nothing @@ -367,7 +367,7 @@ defmodule FLAME.Terminator do if placed_child.timer, do: Process.cancel_timer(placed_child.timer) Process.demonitor(placed_child_ref, [:flush]) DynamicSupervisor.terminate_child(state.child_placement_sup, placed_child.from_pid) - %Terminator{state | calls: Map.delete(state.calls, placed_child_ref)} + %{state | calls: Map.delete(state.calls, placed_child_ref)} else _ -> state end @@ -379,7 +379,7 @@ defmodule FLAME.Terminator do %{^placed_caller_ref => %Caller{} = placed_caller} <- state.calls do if placed_caller.timer, do: Process.cancel_timer(placed_caller.timer) Process.demonitor(placed_caller_ref, [:flush]) - %Terminator{state | calls: Map.delete(state.calls, placed_caller_ref)} + %{state | calls: Map.delete(state.calls, placed_caller_ref)} else _ -> state end @@ -407,19 +407,19 @@ defmodule FLAME.Terminator do case state.idle_shutdown_after do time when time in [nil, :infinity] -> - %Terminator{state | idle_shutdown_timer: {nil, make_ref()}} + %{state | idle_shutdown_timer: {nil, make_ref()}} time when is_integer(time) -> timer_ref = make_ref() timer = Process.send_after(self(), {:idle_shutdown, timer_ref}, time) - %Terminator{state | idle_shutdown_timer: {timer, timer_ref}} + %{state | idle_shutdown_timer: {timer, timer_ref}} end end defp cancel_idle_shutdown(%Terminator{} = state) do {timer, _ref} = state.idle_shutdown_timer if timer, do: Process.cancel_timer(timer) - %Terminator{state | idle_shutdown_timer: {nil, make_ref()}} + %{state | idle_shutdown_timer: {nil, make_ref()}} end defp connect(%Terminator{parent: %Parent{} = parent} = state) do @@ -435,7 +435,7 @@ defmodule FLAME.Terminator do send_parent(parent, {:remote_up, self()}) - %Terminator{ + %{ state | status: :connected, parent_monitor_ref: ref, @@ -444,7 +444,7 @@ defmodule FLAME.Terminator do connect_attempts: new_attempts } else - %Terminator{ + %{ state | connect_timer: Process.send_after(self(), :connect, 100), connect_attempts: new_attempts @@ -458,7 +458,7 @@ defmodule FLAME.Terminator do parent.backend.system_shutdown() end - %Terminator{state | status: :stopping} + %{state | status: :stopping} end defp log(%Terminator{log: level}, message) do