code cleanup

Author: isaacharrisholt

src/barnacle.gleam

@@ -11,24 +11,18 @@ import gleam/result
 import gleam/set
 import gleam/string
 
+// ----- Setup functions ----- //
+
 pub opaque type Barnacle(error) {
   Barnacle(
-    discover_nodes: fn() -> Result(List(atom.Atom), error),
+    strategy: Strategy(error),
     poll_interval: Int,
     listener: Option(Subject(BarnacleResponse(error))),
   )
 }
 
 fn default_barnacle() -> Barnacle(a) {
-  Barnacle(discover_nodes: fn() { Ok([]) }, poll_interval: 5000, listener: None)
-}
-
-pub fn local_epmd() -> Barnacle(Nil) {
-  Barnacle(..default_barnacle(), discover_nodes: local_epmd.discover_nodes)
-}
-
-pub fn epmd(nodes: List(atom.Atom)) -> Barnacle(Nil) {
-  Barnacle(..default_barnacle(), discover_nodes: fn() { Ok(nodes) })
+  Barnacle(strategy: default_strategy(), poll_interval: 5000, listener: None)
 }
 
 pub fn with_poll_interval(
@@ -45,55 +39,120 @@ pub fn with_listener(
   Barnacle(..barnacle, listener: Some(listener))
 }
 
-fn spec(
-  barnacle: Barnacle(error),
-  parent: Option(Subject(Subject(Message(error)))),
-) {
-  actor.Spec(init_timeout: 10_000, loop: handle_message, init: fn() {
-    case refresh_nodes(barnacle) {
-      Ok(_) -> {
-        let self = process.new_subject()
-        let selector =
-          process.new_selector()
-          |> process.selecting(self, function.identity)
+// ----- Strategies ----- //
 
-        option.map(parent, process.send(_, self))
+pub opaque type Strategy(error) {
+  Strategy(
+    discover_nodes: fn() -> Result(List(atom.Atom), error),
+    connect_nodes: fn(List(atom.Atom)) ->
+      Result(List(atom.Atom), List(#(atom.Atom, node.ConnectError))),
+    disconnect_nodes: fn(List(atom.Atom)) ->
+      Result(List(atom.Atom), List(#(atom.Atom, NodeDisconnectError))),
+    list_nodes: fn() -> Result(List(atom.Atom), error),
+  )
+}
 
-        let timer =
-          process.send_after(self, barnacle.poll_interval, Refresh(None))
+pub type NodeDisconnectError {
+  FailedToDisconnect
+  LocalNodeIsNotAlive
+}
 
-        actor.Ready(
-          selector: selector,
-          state: State(self:, barnacle:, timer: Some(timer)),
-        )
-      }
-      Error(err) ->
-        actor.Failed(case err {
-          ConnectError(_) -> "Failed to connect to nodes"
-          DisconnectError(_) -> "Failed to disconnect from nodes"
-          StrategyError(err) ->
-            "Failed to discover nodes: " <> string.inspect(err)
-        })
+fn default_strategy() -> Strategy(error) {
+  Strategy(
+    discover_nodes: fn() { Ok([]) },
+    connect_nodes:,
+    disconnect_nodes:,
+    list_nodes:,
+  )
+}
+
+pub fn new_strategy(
+  discover_nodes: fn() -> Result(List(atom.Atom), error),
+) -> Strategy(error) {
+  Strategy(..default_strategy(), discover_nodes:)
+}
+
+pub fn with_connect_nodes_function(
+  strategy: Strategy(error),
+  connect_nodes: fn(List(atom.Atom)) ->
+    Result(List(atom.Atom), List(#(atom.Atom, node.ConnectError))),
+) -> Strategy(error) {
+  Strategy(..strategy, connect_nodes:)
+}
+
+pub fn with_disconnect_nodes_function(
+  strategy: Strategy(error),
+  disconnect_nodes: fn(List(atom.Atom)) ->
+    Result(List(atom.Atom), List(#(atom.Atom, NodeDisconnectError))),
+) -> Strategy(error) {
+  Strategy(..strategy, disconnect_nodes:)
+}
+
+pub fn with_list_nodes_function(
+  strategy: Strategy(error),
+  list_nodes: fn() -> Result(List(atom.Atom), error),
+) -> Strategy(error) {
+  Strategy(..strategy, list_nodes:)
+}
+
+// ----- Default Strategy ----- //
+
+@external(erlang, "barnacle_ffi", "disconnect_from_node")
+fn disconnect_node(node: atom.Atom) -> Result(node.Node, NodeDisconnectError)
+
+fn list_nodes() -> Result(List(atom.Atom), error) {
+  [node.self(), ..node.visible()]
+  |> list.map(node.to_atom)
+  |> Ok
+}
+
+fn connect_nodes(nodes: List(atom.Atom)) {
+  nodes
+  |> list.map(fn(node) {
+    case node.connect(node) {
+      Ok(_) -> Ok(node)
+      Error(err) -> Error(#(node, err))
     }
   })
+  |> result_apply
 }
 
-pub fn start(
-  barnacle: Barnacle(error),
-  parent: Option(Subject(Subject(Message(error)))),
-) {
-  barnacle
-  |> spec(parent)
-  |> actor.start_spec
+fn disconnect_nodes(nodes: List(atom.Atom)) {
+  nodes
+  |> list.map(fn(node) {
+    case disconnect_node(node) {
+      Ok(_) -> Ok(node)
+      Error(err) -> Error(#(node, err))
+    }
+  })
+  |> result_apply
 }
 
-pub fn child_spec(
-  barnacle: Barnacle(error),
-  parent: Option(Subject(Subject(Message(error)))),
-) {
-  supervisor.worker(fn(_) { start(barnacle, parent) })
+// ----- Built-in Strategies ----- //
+
+pub fn custom(strategy: Strategy(error)) -> Barnacle(error) {
+  Barnacle(..default_barnacle(), strategy:)
+}
+
+pub fn local_epmd() -> Barnacle(Nil) {
+  Barnacle(
+    ..default_barnacle(),
+    strategy: Strategy(
+      ..default_strategy(),
+      discover_nodes: local_epmd.discover_nodes,
+    ),
+  )
+}
+
+pub fn epmd(nodes: List(atom.Atom)) -> Barnacle(Nil) {
+  Barnacle(
+    ..default_barnacle(),
+    strategy: Strategy(..default_strategy(), discover_nodes: fn() { Ok(nodes) }),
+  )
 }
 
+// ----- Actor ----- //
+
 pub type RefreshResult(error) =
   Result(List(atom.Atom), RefreshError(error))
 
@@ -117,13 +176,36 @@ type State(error) {
   )
 }
 
-pub type NodeDisconnectError {
-  FailedToDisconnect
-  LocalNodeIsNotAlive
+pub fn start(
+  barnacle: Barnacle(error),
+  parent: Option(Subject(Subject(Message(error)))),
+) {
+  barnacle
+  |> spec(parent)
+  |> actor.start_spec
 }
 
-@external(erlang, "barnacle_ffi", "disconnect_from_node")
-fn disconnect_node(node: atom.Atom) -> Result(node.Node, NodeDisconnectError)
+pub fn child_spec(
+  barnacle: Barnacle(error),
+  parent: Option(Subject(Subject(Message(error)))),
+) {
+  supervisor.worker(fn(_) { start(barnacle, parent) })
+}
+
+pub fn refresh(
+  subject: Subject(Message(error)),
+  return: Option(Subject(RefreshResult(error))),
+) {
+  process.send(subject, Refresh(return))
+}
+
+pub fn stop(subject: Subject(Message(error)), return: Option(Subject(Nil))) {
+  process.send(subject, Stop(return))
+}
+
+pub fn shutdown(subject: Subject(Message(error)), return: Option(Subject(Nil))) {
+  process.send(subject, Shutdown(return))
+}
 
 pub type RefreshError(error) {
   StrategyError(error)
@@ -160,11 +242,42 @@ fn handle_message(message: Message(error), state: State(error)) {
   }
 }
 
+fn spec(
+  barnacle: Barnacle(error),
+  parent: Option(Subject(Subject(Message(error)))),
+) {
+  actor.Spec(init_timeout: 10_000, loop: handle_message, init: fn() {
+    case refresh_nodes(barnacle) {
+      Ok(_) -> {
+        let self = process.new_subject()
+        let selector =
+          process.new_selector()
+          |> process.selecting(self, function.identity)
+
+        option.map(parent, process.send(_, self))
+
+        let timer =
+          process.send_after(self, barnacle.poll_interval, Refresh(None))
+
+        actor.Ready(
+          selector: selector,
+          state: State(self:, barnacle:, timer: Some(timer)),
+        )
+      }
+      Error(err) ->
+        actor.Failed(case err {
+          ConnectError(_) -> "Failed to connect to nodes"
+          DisconnectError(_) -> "Failed to disconnect from nodes"
+          StrategyError(err) ->
+            "Failed to discover nodes: " <> string.inspect(err)
+        })
+    }
+  })
+}
+
 fn send_response(maybe_client: Option(Subject(a)), response: a) -> Nil {
-  case maybe_client {
-    Some(client) -> process.send(client, response)
-    None -> Nil
-  }
+  option.map(maybe_client, process.send(_, response))
+  Nil
 }
 
 fn cancel_timer(timer: Option(process.Timer)) -> Nil {
@@ -174,69 +287,41 @@ fn cancel_timer(timer: Option(process.Timer)) -> Nil {
 
 fn refresh_nodes(barnacle: Barnacle(error)) -> RefreshResult(error) {
   use available_nodes <- result.try(
-    barnacle.discover_nodes()
+    barnacle.strategy.discover_nodes()
     |> result.map(fn(nodes) {
       set.from_list(nodes)
       |> set.delete(node.self() |> node.to_atom)
     })
     |> result.map_error(StrategyError),
   )
 
+  use current_nodes_list <- result.try(
+    barnacle.strategy.list_nodes()
+    |> result.map_error(StrategyError),
+  )
+
   let current_nodes =
-    node.visible()
-    |> list.map(node.to_atom)
+    current_nodes_list
     |> set.from_list
 
   let nodes_to_add = set.difference(available_nodes, current_nodes)
   let nodes_to_remove = set.difference(current_nodes, available_nodes)
 
-  let connect_results = connect_nodes(nodes_to_add |> set.to_list)
+  let connect_results =
+    barnacle.strategy.connect_nodes(nodes_to_add |> set.to_list)
   use _ <- result.try(connect_results |> result.map_error(ConnectError))
 
-  let disconnect_results = disconnect_nodes(nodes_to_remove |> set.to_list)
+  let disconnect_results =
+    barnacle.strategy.disconnect_nodes(nodes_to_remove |> set.to_list)
   use _ <- result.try(disconnect_results |> result.map_error(DisconnectError))
 
-  Ok(node.visible() |> list.map(node.to_atom))
-}
-
-fn connect_nodes(nodes: List(atom.Atom)) {
-  nodes
-  |> list.map(fn(node) {
-    case node.connect(node) {
-      Ok(_) -> Ok(Nil)
-      Error(err) -> Error(#(node, err))
-    }
-  })
-  |> result_apply
-}
-
-fn disconnect_nodes(nodes: List(atom.Atom)) {
-  nodes
-  |> list.map(fn(node) {
-    case disconnect_node(node) {
-      Ok(_) -> Ok(Nil)
-      Error(err) -> Error(#(node, err))
-    }
-  })
-  |> result_apply
+  barnacle.strategy.list_nodes()
+  |> result.map_error(StrategyError)
 }
 
 fn result_apply(results: List(Result(a, b))) -> Result(List(a), List(b)) {
-  results
-  |> list.fold(Ok([]), fn(acc, result) {
-    case result {
-      Ok(val) -> {
-        case acc {
-          Ok(vals) -> Ok([val, ..vals])
-          Error(_) -> acc
-        }
-      }
-      Error(err) -> {
-        case acc {
-          Ok(_) -> Error([err])
-          Error(errs) -> Error([err, ..errs])
-        }
-      }
-    }
-  })
+  case result.partition(results) {
+    #(vals, []) -> Ok(vals)
+    #(_, errs) -> Error(errs)
+  }
 }