initial commit

Author: isaacharrisholt

.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: test
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: "26.0.2"
+          gleam-version: "1.4.1"
+          rebar3-version: "3"
+          # elixir-version: "1.15.4"
+      - run: gleam deps download
+      - run: gleam test
+      - run: gleam format --check src test

.gitignore

@@ -0,0 +1,4 @@
+*.beam
+*.ez
+/build
+erl_crash.dump

README.md

@@ -0,0 +1,24 @@
+# barnacle
+
+[![Package Version](https://img.shields.io/hexpm/v/barnacle)](https://hex.pm/packages/barnacle)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/barnacle/)
+
+```sh
+gleam add barnacle@1
+```
+```gleam
+import barnacle
+
+pub fn main() {
+  // TODO: An example of the project in use
+}
+```
+
+Further documentation can be found at <https://hexdocs.pm/barnacle>.
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+```

gleam.toml

@@ -0,0 +1,21 @@
+name = "barnacle"
+version = "1.0.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# description = ""
+# licences = ["Apache-2.0"]
+# repository = { type = "github", user = "", repo = "" }
+# links = [{ title = "Website", href = "" }]
+#
+# For a full reference of all the available options, you can have a look at
+# https://gleam.run/writing-gleam/gleam-toml/.
+
+[dependencies]
+gleam_stdlib = ">= 0.34.0 and < 2.0.0"
+gleam_erlang = ">= 0.27.0 and < 1.0.0"
+gleam_otp = ">= 0.12.1 and < 1.0.0"
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

@@ -0,0 +1,15 @@
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "gleam_erlang", version = "0.27.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "DE468F676D71B313C6C8C5334425CFCF827837333F8AB47B64D8A6D7AA40185D" },
+  { name = "gleam_otp", version = "0.12.1", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "BFACC1513410DF5A1617169A9CD7EA334973AC71D860A17574BA7B2EADD89A6F" },
+  { name = "gleam_stdlib", version = "0.40.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "86606B75A600BBD05E539EB59FABC6E307EEEA7B1E5865AFB6D980A93BCB2181" },
+  { name = "gleeunit", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "F7A7228925D3EE7D0813C922E062BFD6D7E9310F0BEE585D3A42F3307E3CFD13" },
+]
+
+[requirements]
+gleam_erlang = { version = ">= 0.27.0 and < 1.0.0" }
+gleam_otp = { version = ">= 0.12.1 and < 1.0.0" }
+gleam_stdlib = { version = ">= 0.34.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

src/barnacle.gleam

@@ -0,0 +1,224 @@
+import barnacle/internal/local_epmd
+import gleam/erlang/atom
+import gleam/erlang/node
+import gleam/erlang/process.{type Subject}
+import gleam/function
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/otp/actor
+import gleam/otp/supervisor
+import gleam/result
+import gleam/set
+import gleam/string
+
+pub opaque type Barnacle(error) {
+  Barnacle(
+    discover_nodes: fn() -> Result(List(atom.Atom), error),
+    poll_interval: Int,
+  )
+}
+
+fn default_barnacle() -> Barnacle(a) {
+  Barnacle(discover_nodes: fn() { Ok([]) }, poll_interval: 5000)
+}
+
+pub fn local_epmd() -> Barnacle(Nil) {
+  Barnacle(..default_barnacle(), discover_nodes: local_epmd.discover_nodes)
+}
+
+pub fn with_poll_interval(
+  barnacle: Barnacle(error),
+  poll_interval: Int,
+) -> Barnacle(error) {
+  Barnacle(..barnacle, poll_interval: poll_interval)
+}
+
+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)
+        })
+    }
+  })
+}
+
+pub fn start(
+  barnacle: Barnacle(error),
+  parent: Option(Subject(Subject(Message(error)))),
+) {
+  barnacle
+  |> spec(parent)
+  |> actor.start_spec
+}
+
+pub fn child_spec(
+  barnacle: Barnacle(error),
+  parent: Option(Subject(Subject(Message(error)))),
+) {
+  supervisor.worker(fn(_) { start(barnacle, parent) })
+}
+
+pub fn main() {
+  let self = process.new_subject()
+  let assert Ok(child) =
+    local_epmd()
+    |> start(None)
+
+  process.send(child, Refresh(Some(self)))
+
+  let assert Ok(msg) = process.receive(self, 10_000)
+
+  process.sleep_forever()
+}
+
+pub type RefreshResult(error) =
+  Result(List(atom.Atom), RefreshError(error))
+
+pub opaque type Message(error) {
+  Refresh(return: Option(Subject(RefreshResult(error))))
+  Stop(return: Option(Subject(Nil)))
+  Shutdown(return: Option(Subject(Nil)))
+}
+
+type State(error) {
+  State(
+    self: Subject(Message(error)),
+    barnacle: Barnacle(error),
+    timer: Option(process.Timer),
+  )
+}
+
+pub type NodeDisconnectError {
+  FailedToDisconnect
+  LocalNodeIsNotAlive
+}
+
+@external(erlang, "barnacle_ffi", "disconnect_from_node")
+fn disconnect_node(node: atom.Atom) -> Result(node.Node, NodeDisconnectError)
+
+pub type RefreshError(error) {
+  StrategyError(error)
+  ConnectError(List(#(atom.Atom, node.ConnectError)))
+  DisconnectError(List(#(atom.Atom, NodeDisconnectError)))
+}
+
+fn handle_message(message: Message(error), state: State(error)) {
+  let State(self:, barnacle:, timer:) = state
+  case message {
+    Refresh(return) -> {
+      let refresh_result = refresh_nodes(barnacle)
+      send_response(return, refresh_result)
+
+      let timer =
+        process.send_after(self, barnacle.poll_interval, Refresh(None))
+      actor.continue(State(..state, timer: Some(timer)))
+    }
+    Stop(return) -> {
+      option.map(timer, process.cancel_timer)
+      send_response(return, Nil)
+      actor.continue(State(..state, timer: None))
+    }
+    Shutdown(return) -> {
+      option.map(timer, process.cancel_timer)
+      send_response(return, Nil)
+      actor.Stop(process.Normal)
+    }
+  }
+}
+
+fn send_response(maybe_client: Option(Subject(a)), response: a) -> Nil {
+  case maybe_client {
+    Some(client) -> process.send(client, response)
+    None -> Nil
+  }
+}
+
+fn refresh_nodes(barnacle: Barnacle(error)) -> RefreshResult(error) {
+  use available_nodes <- result.try(
+    barnacle.discover_nodes()
+    |> result.map(fn(nodes) {
+      set.from_list(nodes)
+      |> set.delete(node.self() |> node.to_atom)
+    })
+    |> result.map_error(StrategyError),
+  )
+
+  let current_nodes =
+    node.visible()
+    |> list.map(node.to_atom)
+    |> 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 =
+    nodes_to_add
+    |> set.to_list
+    |> list.map(fn(node) {
+      case node.connect(node) {
+        Ok(_) -> Ok(Nil)
+        Error(err) -> Error(#(node, err))
+      }
+    })
+    |> result_apply
+
+  use _ <- result.try(connect_results |> result.map_error(ConnectError))
+
+  let disconnect_results =
+    nodes_to_remove
+    |> set.to_list
+    |> list.map(fn(node) {
+      case disconnect_node(node) {
+        Ok(_) -> Ok(Nil)
+        Error(err) -> Error(#(node, err))
+      }
+    })
+    |> result_apply
+
+  use _ <- result.try(disconnect_results |> result.map_error(DisconnectError))
+
+  Ok(node.visible() |> list.map(node.to_atom))
+}
+
+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])
+        }
+      }
+    }
+  })
+}

src/barnacle/internal/actor.gleam

@@ -0,0 +1,26 @@
+import gleam/erlang/atom
+import gleam/erlang/node
+import gleam/list
+import gleam/result
+import gleam/string
+
+@external(erlang, "barnacle_ffi", "list_local_nodes")
+fn list_local_nodes() -> Result(List(String), Nil)
+
+fn get_hostname() -> String {
+  let host =
+    node.self()
+    |> node.to_atom
+    |> atom.to_string
+
+  let assert [_, hostname] = string.split(host, "@")
+  hostname
+}
+
+pub fn discover_nodes() -> Result(List(atom.Atom), Nil) {
+  let hostname = get_hostname()
+  list_local_nodes()
+  |> result.map(list.map(_, fn(n) {
+    { n <> "@" <> hostname } |> atom.create_from_string
+  }))
+}

src/barnacle/internal/local_epmd.gleam

@@ -0,0 +1,21 @@
+-module(barnacle_ffi).
+
+-export([list_local_nodes/0, disconnect_from_node/1]).
+
+list_local_nodes() ->
+  case erl_epmd:names() of
+    {error, address} ->
+      {error, nil};
+    {ok, Names} ->
+      {ok, [list_to_binary(Name) || {Name, _} <- Names]}
+  end.
+
+disconnect_from_node(Node) ->
+  case disconnect_node(Node) of
+    true ->
+      {ok, Node};
+    false ->
+      {error, failed_to_disconnect};
+    ignored ->
+      {error, local_node_is_not_alive}
+  end.

src/barnacle_ffi.erl

@@ -0,0 +1,12 @@
+import gleeunit
+import gleeunit/should
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// gleeunit test functions end in `_test`
+pub fn hello_world_test() {
+  1
+  |> should.equal(1)
+}