From bdacd9905eb90646eab99385a13da0bdcaf7031d Mon Sep 17 00:00:00 2001 From: bluepython508 <16466646+bluepython508@users.noreply.github.com> Date: Thu, 26 Sep 2024 13:06:58 +0100 Subject: [PATCH] Rename Peer to 'Backing Agent' --- config/config.exs | 2 +- default.nix | 2 +- flake.nix | 8 ++++---- lib/agent.ex | 38 +++++++++++++++++++------------------- lib/frajtano.ex | 6 +++--- lib/peer.ex | 22 +++++++++++----------- 6 files changed, 39 insertions(+), 39 deletions(-) diff --git a/config/config.exs b/config/config.exs index a238fac..0459263 100644 --- a/config/config.exs +++ b/config/config.exs @@ -1,4 +1,4 @@ import Config config :frajtano, - initial_peers: [] + initial_backing_agents: [] diff --git a/default.nix b/default.nix index a5765db..c2a2b0e 100644 --- a/default.nix +++ b/default.nix @@ -58,7 +58,7 @@ ;; spawn) shift - run rpc ":ok = Frajtano.Agent.spawn_peer({\"/usr/bin/env\", [$(list "$@")]})" + run rpc ":ok = Frajtano.Agent.spawn_backing_agent({\"/usr/bin/env\", [$(list "$@")]})" ;; socket) echo $FRAJTANO_DIR/agent.sock diff --git a/flake.nix b/flake.nix index a26adc5..d7a4d28 100644 --- a/flake.nix +++ b/flake.nix @@ -42,18 +42,18 @@ default = "${config.home.homeDirectory}/.ssh/frajtano"; type = lib.types.path; }; - initialPeers = lib.mkOption { - description = "initially spawned peers - will be passed to /usr/bin/env"; + initialBackingAgents = lib.mkOption { + description = "initially spawned backing_agents - will be passed to /usr/bin/env"; type = with lib.types; listOf (listOf str); default = []; }; }; config = let - peers = lib.strings.concatMapStringsSep ", " (args: ''{:spawn, {"${pkgs.coreutils}/bin/env", [${lib.concatMapStringsSep ", " (s: ''~S{${s}}'') args}]}}'') cfg.initialPeers; + backing_agents = lib.strings.concatMapStringsSep ", " (args: ''{:spawn, {"${pkgs.coreutils}/bin/env", [${lib.concatMapStringsSep ", " (s: ''~S{${s}}'') args}]}}'') cfg.initialBackingAgents; configFile = pkgs.writeText "config.exs" '' import Config - config :frajtano, initial_peers: [${peers}] + config :frajtano, initial_backing_agents: [${backing_agents}] ''; in lib.mkIf cfg.enable { home.sessionVariables.FRAJTANO_DIR = cfg.dir; diff --git a/lib/agent.ex b/lib/agent.ex index 87e6d86..ff84af6 100644 --- a/lib/agent.ex +++ b/lib/agent.ex @@ -1,5 +1,5 @@ defmodule Frajtano.Agent do - alias Frajtano.Peer + alias Frajtano.BackingAgent use GenServer require Logger @@ -15,49 +15,49 @@ defmodule Frajtano.Agent do } end - def initial_peers() do - initial_peers = Application.fetch_env!(:frajtano, :initial_peers) - |> Enum.map(&GenServer.call(__MODULE__, {:add_peer, &1})) - Logger.info("Started initial peers: #{inspect initial_peers}") + def initial_backing_agents() do + initial_backing_agents = Application.fetch_env!(:frajtano, :initial_backing_agents) + |> Enum.map(&GenServer.call(__MODULE__, {:add_backing_agent, &1})) + Logger.info("Started initial backing_agents: #{inspect initial_backing_agents}") end # select: list of specs, where specs are a tuple of match, guards, and outputs # match is {key, pid, value}, :"$1" is a match variable - def peer_paths() do - Registry.select(Frajtano.Peers, [{{:"$1", :_, :_}, [], [:"$1"]}]) + def backing_agent_paths() do + Registry.select(Frajtano.BackingAgents, [{{:"$1", :_, :_}, [], [:"$1"]}]) end - def peer_pids() do - Registry.select(Frajtano.Peers, [{{:_, :"$1", :_}, [], [:"$1"]}]) + def backing_agent_pids() do + Registry.select(Frajtano.BackingAgents, [{{:_, :"$1", :_}, [], [:"$1"]}]) end @impl true def handle_call({:identities}, _from, _state) do idents = Task.async_stream( - peer_pids(), - &{&1, Peer.identities(&1)}, + backing_agent_pids(), + &{&1, BackingAgent.identities(&1)}, ordered: false, on_timeout: :kill_task ) - idents = for {:ok, {peer, {:ok, idents}}} <- idents, do: {idents, peer} + idents = for {:ok, {backing_agent, {:ok, idents}}} <- idents, do: {idents, backing_agent} { :reply, {:ok, idents |> Enum.flat_map(&elem(&1, 0)) |> Enum.uniq}, - for({idents, peer} <- idents, {key, _comment} <- idents, into: %{}, do: {key, peer}) + for({idents, backing_agent} <- idents, {key, _comment} <- idents, into: %{}, do: {key, backing_agent}) } end @impl true def handle_call({:sign, {key, _, _} = req}, _from, state) do - {:reply, Peer.sign(state[key], req), state} + {:reply, BackingAgent.sign(state[key], req), state} end @impl true - def handle_call({:add_peer, spec}, _from, state) do - case Peer.start(spec) do + def handle_call({:add_backing_agent, spec}, _from, state) do + case BackingAgent.start(spec) do {:ok, _} -> {:reply, :ok, state} {:error, error} -> {:reply, {:error, error}, state} end @@ -73,10 +73,10 @@ defmodule Frajtano.Agent do end def assimilate(path) do - GenServer.call(__MODULE__, {:add_peer, {:socket, path}}) + GenServer.call(__MODULE__, {:add_backing_agent, {:socket, path}}) end - def spawn_peer(spec) do - GenServer.call(__MODULE__, {:add_peer, {:spawn, spec}}) + def spawn_backing_agent(spec) do + GenServer.call(__MODULE__, {:add_backing_agent, {:spawn, spec}}) end end diff --git a/lib/frajtano.ex b/lib/frajtano.ex index 72019bf..cb65053 100644 --- a/lib/frajtano.ex +++ b/lib/frajtano.ex @@ -17,12 +17,12 @@ defmodule Frajtano.Supervisor do @impl true def init(:ok) do children = [ - {DynamicSupervisor, name: Frajtano.PeerSupervisor}, - {Registry, keys: :unique, name: Frajtano.Peers}, + {DynamicSupervisor, name: Frajtano.BackingAgentSupervisor}, + {Registry, keys: :unique, name: Frajtano.BackingAgents}, Frajtano.Agent, {Task.Supervisor, name: Frajtano.ClientSupervisor}, {Frajtano.Listener, [Application.fetch_env!(:frajtano, :listen_path)]}, - {Task, &Frajtano.Agent.initial_peers/0}, + {Task, &Frajtano.Agent.initial_backing_agents/0}, :systemd.ready(), ] diff --git a/lib/peer.ex b/lib/peer.ex index 9ed3d72..261e929 100644 --- a/lib/peer.ex +++ b/lib/peer.ex @@ -1,4 +1,4 @@ -defmodule Frajtano.Peer do +defmodule Frajtano.BackingAgent do alias Frajtano.Proto require Logger use GenServer, restart: :temporary @@ -17,7 +17,7 @@ defmodule Frajtano.Peer do children = [ Supervisor.child_spec({MuonTrap.Daemon, [executable, args ++ [path]]}, restart: :temporary, significant: true), - Supervisor.child_spec({Frajtano.Peer, {path, :spawned, {executable, args}}}, restart: :permanent) + Supervisor.child_spec({Frajtano.BackingAgent, {path, :spawned, {executable, args}}}, restart: :permanent) ] Supervisor.init(children, strategy: :one_for_all, auto_shutdown: :any_significant) @@ -25,19 +25,19 @@ defmodule Frajtano.Peer do end def start({:socket, path}) do - DynamicSupervisor.start_child(Frajtano.PeerSupervisor, {__MODULE__, {path}}) + DynamicSupervisor.start_child(Frajtano.BackingAgentSupervisor, {__MODULE__, {path}}) end def start({:spawn, spec}) do Logger.info("Spawning #{inspect spec}") - DynamicSupervisor.start_child(Frajtano.PeerSupervisor, {Spawner, spec}) + DynamicSupervisor.start_child(Frajtano.BackingAgentSupervisor, {Spawner, spec}) end def start_link({path}) do - GenServer.start_link(__MODULE__, {path}, name: {:via, Registry, {Frajtano.Peers, path}}) + GenServer.start_link(__MODULE__, {path}, name: {:via, Registry, {Frajtano.BackingAgents, path}}) end def start_link({_, _, _} = spec) do - GenServer.start_link(__MODULE__, spec, name: {:via, Registry, {Frajtano.Peers, spec}}) + GenServer.start_link(__MODULE__, spec, name: {:via, Registry, {Frajtano.BackingAgents, spec}}) end @impl true @@ -112,12 +112,12 @@ defmodule Frajtano.Peer do {:stop, {:error, e}, %{}} end - def identities(peer) do + def identities(backing_agent) do ref = make_ref() - send(peer, {:send, {:agentc_request_identities, nil}, {self(), ref}}) + send(backing_agent, {:send, {:agentc_request_identities, nil}, {self(), ref}}) # Needs to be less than the timeout in Frajtano.Agent.identities on the Task.async_stream call # That's 5000 by default - timer = Process.send_after(peer, :timeout, 4500) + timer = Process.send_after(backing_agent, :timeout, 4500) receive do {^ref, msg} -> @@ -132,13 +132,13 @@ defmodule Frajtano.Peer do end end - def sign(peer, request) do + def sign(backing_agent, request) do # Signing may take some time, as a password may need to be entered or similar # There is therefore no timeout # If something requests identities afterwards, it will timeout, which also kills this signature request # The SSH agent protocol strict ordering leaves fun problems with timeouts, as it turns out ref = make_ref() - send(peer, {:send, {:agentc_sign_request, request}, {self(), ref}}) + send(backing_agent, {:send, {:agentc_sign_request, request}, {self(), ref}}) receive do {^ref, msg} -> msg