Hacker News Reader

Comment by moomoo11 | Hacker News Reader

Can someone please give advice on how to accomplish the following with phoenix sockets?

Say I have processes for each physical device in the world that are moving around (like on water or something). Any time there is an “anomaly” I want to double check by having all nearby processes/devices run the same check again.

Is there a way to run a filter by geoquerying without having to rely on storing the coordinates in a separate store and querying for those device/process IDs? I can store the coordinates in each process, and I want to be able to find nearby processes in one go without using a separate system for finding them.

I’m quite a noob at phoenix..

View on HN

I stopped using Phoenix a few years ago, but I'd do something roughly as follows:

- Imagine a grid where each cell is a 1x1 square mile based on lat/lon

- When a device moves to a new cell, have it join the phx-channel representing that 1x1 cell. It must also leave the previous phx-channel of the cell it occupied. If your devices move very slowly, have them recalculate the cell/channel they belong to once an hour (for example).

- When an anomaly occurs, send a message to the channel. Every device in that cell will receive the websocket message. You may also choose to send your message to the 3x3 cells that surround just the cell where the anomaly occurred.

- If you need to tell all devices something, use broadcast.

Feel free to change 1x1 mile to 1x1 meters or whatever.

simple solution: store the geohashes and compare prefixes, each prefix length is equivalent to a distance.

https://en.wikipedia.org/wiki/Geohash#Digits_and_precision_i...

you can use this pure Elixir library

https://hex.pm/packages/geohash

or this NIF that wraps a much faster C library

https://hex.pm/packages/geohash_nif

or use one of the many geo libraries, like this one

https://github.com/yltsrc/geocalc

(not sure where the "phoenix sockets" fit into it)

1/ So I guess you're saying one process/GenServer per device, communicating with it.

2/ Use a Registry[0] to store the process names (based on the device id or whatever) to abstract them from their PID.

3/ Have another GenServer (let's call it CoordStore) storing a map of "process_name -> lat/long" (with the related processes sending updates of the coordinates to it)

4/ Use Presence[1] to keep track of the devices and remove them from the CoordStore when needed.

5/ When you have an anomaly on one device ask CoordStore for the nearby devices/processes (using maybe [2]) and ask each one (thanks to the Registry) to run the check.

6/ Done?

(sure you can do a barebone version without the Registry or Presence but where's the fun in that?)

[0] https://hexdocs.pm/elixir/1.14.3/Registry.html

[1] https://hexdocs.pm/phoenix/Phoenix.Presence.html

[2] https://github.com/yltsrc/geocalc

Simplest thing is to use Phoenix PubSub. Broadcast an "anomaly at x,y,z coordinates" message. Then each process can calculate whether it is close and needs to do anything. This isn't very efficient because every process will do some work for every anomaly, but unless your system is very large that's probably OK (it as least extremely parallelised).

The alternate approach is to create some form of central process registry that has all the coordinates and process ids, so that you can look up in one place and then send messages out to the relevant processes. There are some other replies about this sort of approach.

why do you need the phoenix part? maybe consider a short-distance wireless comm like bluetooth or zigbee and have them broadcast to nearby devices? have the devices respond to the re-check broadcast and physics will take care of the locating nearby devices part

Reply on news.ycombinator.com