Add some more logic, not final API, just trying it out

Author: sbergen

dev/esdee_dev.gleam

@@ -0,0 +1,16 @@
+import esdee
+
+pub fn main() {
+  let assert Ok(discovery) =
+    esdee.new()
+    |> esdee.start()
+
+  //let assert Ok(_) = esdee.discover(discovery, "_googlecast._tcp.local")
+  let assert Ok(_) = esdee.discover(discovery, "_services._dns-sd._udp.local")
+  recieve_forever(discovery)
+}
+
+fn recieve_forever(discovery) {
+  echo esdee.receive_next(discovery, 10_000)
+  recieve_forever(discovery)
+}

gleam.toml

@@ -15,7 +15,7 @@ version = "1.0.0"
 [dependencies]
 gleam_stdlib = ">= 0.44.0 and < 2.0.0"
 gleam_erlang = ">= 1.3.0 and < 2.0.0"
+toss = { path = "../toss" }
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"
-

manifest.toml

@@ -5,9 +5,11 @@ packages = [
   { name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
   { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
   { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },
+  { name = "toss", version = "1.0.0-rc2", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], source = "local", path = "../toss" },
 ]
 
 [requirements]
 gleam_erlang = { version = ">= 1.3.0 and < 2.0.0" }
 gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
+toss = { path = "../toss" }

src/esdee.gleam

@@ -1,15 +1,176 @@
-import gleam/option
+import esdee/internal/dns.{type ResourceRecord}
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/result
+import toss
 
+const mds_port = 5353
+
+/// Describes a service fully discovered via DNS-SD.
 pub type ServiceDescription {
   ServiceDescription(
+    /// The service type string, e.g. _googlecast._tcp.local
     service_type: String,
+    /// The unique instance name for a peer providing the service, e.g.
+    /// SHIELD-Android-TV-9693d58e3537dddb118b7b7d17f9c1c2._googlecast._tcp.local
     instance_name: String,
+    /// The target host name, which can be used to actually connect to the service, e.g.
+    /// 9693d58e-3537-dddb-118b-7b7d17f9c1c2.local
     target_name: String,
+    /// The priority of the target host, lower value means more preferred.
+    /// Originates from the SRV record.
     priority: Int,
+    /// A relative weight for records with the same priority,
+    /// higher value means higher chance of getting picked.
+    /// Originates from the SRV record.
     weight: Int,
+    /// The port the service is served on.
     port: Int,
+    /// Any TXT records that the service advertises (can be empty).
     txt_values: List(String),
-    ipv4: option.Option(#(Int, Int, Int, Int)),
-    ipv6: option.Option(#(Int, Int, Int, Int, Int, Int, Int, Int)),
+    /// The IPv4 address, if advertised.
+    ipv4: Option(#(Int, Int, Int, Int)),
+    /// The IPv6 address, if advertised.
+    ipv6: Option(#(Int, Int, Int, Int, Int, Int, Int, Int)),
   )
 }
+
+// For future options, e.g. IPv6
+pub opaque type Options {
+  Options(max_data_size: Int, broadcast_ip: toss.IpAddress)
+}
+
+pub opaque type ServiceDiscovery {
+  ServiceDiscovery(options: Options, socket: toss.Socket)
+}
+
+pub fn new() -> Options {
+  Options(max_data_size: 4096, broadcast_ip: toss.Ipv4Address(224, 0, 0, 251))
+}
+
+pub type StartError {
+  CouldNotOpenSocket
+  CouldNotJoinMulticast
+}
+
+pub fn start(options: Options) -> Result(ServiceDiscovery, StartError) {
+  use socket <- result.try(
+    toss.new(mds_port)
+    |> toss.use_ipv4()
+    |> toss.reuse_address()
+    |> toss.using_interface(options.broadcast_ip)
+    |> toss.open
+    |> result.replace_error(CouldNotOpenSocket),
+  )
+
+  let local_addr = toss.Ipv4Address(0, 0, 0, 0)
+  use _ <- result.try(
+    toss.join_multicast_group(socket, options.broadcast_ip, local_addr)
+    |> result.replace_error(CouldNotJoinMulticast),
+  )
+
+  Ok(ServiceDiscovery(options, socket))
+}
+
+pub fn discover(
+  discovery: ServiceDiscovery,
+  service: String,
+) -> Result(Nil, Nil) {
+  let data = dns.encode_question(service)
+  toss.send_to(discovery.socket, discovery.options.broadcast_ip, mds_port, data)
+  |> result.replace_error(Nil)
+}
+
+pub type DiscoveryError {
+  ReceiveTimeout
+  ReceiveError
+  NotAnAnswer
+  InvalidDnsData
+  InsufficientData
+}
+
+pub fn receive_next(
+  discovery: ServiceDiscovery,
+  timeout_ms: Int,
+) -> Result(ServiceDescription, DiscoveryError) {
+  use #(_, _, data) <- result.try(
+    toss.receive(discovery.socket, discovery.options.max_data_size, timeout_ms)
+    |> result.map_error(fn(e) {
+      case e {
+        toss.Timeout -> ReceiveTimeout
+        _ -> ReceiveError
+      }
+    }),
+  )
+
+  use records <- result.try(
+    dns.decode_records(data)
+    |> result.map_error(fn(e) {
+      case e {
+        dns.InvalidData -> InvalidDnsData
+        dns.NotAnAnswer -> NotAnAnswer
+      }
+    }),
+  )
+
+  description_from_records(records) |> result.replace_error(InsufficientData)
+}
+
+fn description_from_records(
+  records: List(ResourceRecord),
+) -> Result(ServiceDescription, Nil) {
+  echo records
+
+  let try_find = fn(with: fn(ResourceRecord) -> Result(a, Nil), apply) {
+    result.try(list.find_map(records, with), apply)
+  }
+
+  use #(service_type, instance_name) <- try_find(fn(record) {
+    case record {
+      dns.PtrRecord(service_type:, instance_name:) ->
+        Ok(#(service_type, instance_name))
+      _ -> Error(Nil)
+    }
+  })
+
+  use #(priority, weight, port, target_name) <- try_find(fn(record) {
+    case record {
+      dns.SrvRecord(priority:, weight:, port:, target_name:, ..) ->
+        Ok(#(priority, weight, port, target_name))
+      _ -> Error(Nil)
+    }
+  })
+
+  let #(ipv4, ipv6) =
+    list.fold(records, #(None, None), fn(ips, record) {
+      case record {
+        dns.ARecord(ip:, ..) -> #(Some(ip), ips.1)
+        dns.AaaaRecord(ip:, ..) -> #(ips.0, Some(ip))
+        _ -> ips
+      }
+    })
+
+  let txt_values =
+    list.flat_map(records, fn(record) {
+      case record {
+        dns.TxtRecord(values:, ..) -> values
+        _ -> []
+      }
+    })
+
+  case option.is_some(ipv4) || option.is_some(ipv6) {
+    True ->
+      Ok(ServiceDescription(
+        service_type:,
+        instance_name:,
+        target_name:,
+        priority:,
+        weight:,
+        port:,
+        txt_values:,
+        ipv4:,
+        ipv6:,
+      ))
+    False -> Error(Nil)
+  }
+}

src/esdee/internal/dns.gleam

@@ -19,7 +19,14 @@ pub type ResourceRecord {
   AaaaRecord(target_name: String, ip: #(Int, Int, Int, Int, Int, Int, Int, Int))
 }
 
+pub type DecodeError {
+  InvalidData
+  NotAnAnswer
+}
+
 /// Decode the resource records out of a binary DNS record.
 /// We don't currently care about the header or other entries.
 @external(erlang, "esdee_ffi", "decode_records")
-pub fn decode_records(data: BitArray) -> Result(List(ResourceRecord), Nil)
+pub fn decode_records(
+  data: BitArray,
+) -> Result(List(ResourceRecord), DecodeError)

src/esdee_ffi.erl

@@ -23,10 +23,10 @@ decode_records(Bits) ->
           Resources = lists:filtermap(fun map_resource/1, Record#dns_rec.arlist),
           {ok, Answers ++ Resources};
         _ ->
-          {ok, []}
+          {error, not_an_answer}
       end;
     _ ->
-      {error, nil}
+      {error, invalid_data}
   end.
 
 map_answer(Answer) ->

test/esdee/internal/dns_test.gleam

@@ -49,11 +49,11 @@ pub fn encode_question_test() {
 }
 
 pub fn decode_records_fail_test() {
-  assert dns.decode_records(<<"Not valid":utf8>>) == Error(Nil)
+  assert dns.decode_records(<<"Not valid":utf8>>) == Error(dns.InvalidData)
 }
 
-pub fn decode_records_skip_question_test() {
-  assert dns.decode_records(query_bits) == Ok([])
+pub fn decode_records_question_test() {
+  assert dns.decode_records(query_bits) == Error(dns.NotAnAnswer)
 }
 
 pub fn decode_records_test() {