Elixir Cowboy Websocket - 위도 경도 근접성으로 IOT 장치 쿼리

가능한 사용 사례

목차

종속성

  defp deps do
    [
      {:cowboy, "~> 2.4"},
      {:plug_cowboy, "~> 2.0"},
      {:jason, "~> 1.3"},
      {:geocoder, "~> 1.1"},
      {:geocalc, "~> 0.8"}
    ]
  end

응용 프로그램

defmodule IotDevicesApp do
  use Application
  def start(_type, _args) do

    children = [
      Plug.Cowboy.child_spec(
        scheme: :http,
        plug:  SocketApp.HttpRouter,
        options: [dispatch: dispatch(),port: 5000]
      ),
      Registry.child_spec(
        keys: :duplicate,
        name: Registry.IotApp
      )
    ]

    opts = [strategy: :one_for_one, name: IotDevicesApp.Application]
    Supervisor.start_link(children, opts)
  end

  defp dispatch do
    [
      {:_,
        [
          {"/ws/[...]", IotDevicesApp.SocketHandlerLocation, []},
          {:_, Plug.Cowboy.Handler, {SocketApp.HttpRouter, []}}
        ]
      }
    ]
  end  
end

공간 구역화

def getZone({lon, lat}) do 
  {:ok, coord} = Geocoder.call({lat, lon}, provider: Geocoder.Providers.OpenStreetMaps)
  # OpenStreetMaps is only for testing, it is limited to 1 request by second.
  "#{coord.location.state}, #{coord.location.city}"
end

times_square = {-73.985130,40.758896}
getZone(times_square)
Return : "New York, New York"

거리로 필터링

def distance({cx, cy}, {nx, ny}) do
  :math.sqrt(:math.pow(abs(cx - nx), 2) + :math.pow(abs(cy - ny), 2))
end

def distance({cx, cy}, {nx, ny}) do  
  Geocalc.distance_between([cx, cy], [nx, ny])
end

장치 레지스트리

소켓 핸들러

defmodule IotDevicesApp.SocketHandlerLocation do
  @behaviour :cowboy_websocket
  @degrees  0.5
  @meters   1500

  # When a client open the connection, it send to us his latitude and longitude
  # javascript: websocket = new WebSocket("ws://192.168.1.109:5000/ws?lon=-73.985130&lat=40.758896");
  def init(request, _state) do   

    vars = URI.query_decoder(request.qs) |> Map.new()    

    lon_float = String.to_float(Map.get(vars, "lon", 0.0))
    lat_float = String.to_float(Map.get(vars, "lat", 0.0))
    {:cowboy_websocket, request, {lon_float, lat_float}, %{idle_timeout: :infinity}}
  end


  # Called once the connection has been upgraded to Websocket.

  def websocket_init(location) do
    IO.puts("-------------websocket_init--------------")
    # this function have different PID that the init() function    
    # for that reason the PID registration is here
    key = getZone(location)
    Registry.IotApp
    |> Registry.register(key, location)

    {:ok, {key, location}}
  end

  # websocket_handle called when:
  # javascript: websocket.send(JSON.stringify({action:"updlocation", lon:11, lat:22})
  # javascript: websocket.send(JSON.stringify({action:"status", ...status})
  # javascript: websocket.send(JSON.stringify({action:"wakeupneighbors"})

  def websocket_handle({:text, json}, state = {key, location}) do
    IO.puts("-------------websocket_handle--------------")

    IO.inspect(state, label: "state")

    payload = Jason.decode!(json)

    case payload["action"] do
      "status" -> {:reply, reportStatus(payload["status"]), state}
      "updlocation" -> updateLocation(self(), key, {payload["lon"], payload["lat"]})
      "wakeupneighbors" -> {:reply, wakeupNeighbors(key, location), state}
      _ -> {:ok, state}
    end
  end


  # Here broadcast happen
  # websocket_info: Will be called for every Erlang message received.
  # Trigger from  wakeupNeighbors()
  def websocket_info(info, state) do
    {:reply, {:text, info}, state}
  end

  #----------- Next are utilities functions ---------------------

  def reportStatus(status) do
    IO.puts("-------------reportStatus--------------")
    IO.inspect(status ,label: "status")
    # Here put your logic
    {:ok, str} = Jason.encode(%{"action"=>"ack"})
    {:text, str}
  end

  def updateLocation(pid, oldkey, newlocation) do
    IO.puts("-------------updateLocation--------------")
    IO.inspect({pid, self()}, label: "PID")
    # this function have same PID that the websocket_init() function
    # IO.inspect(newlocation ,label: "newlocation")
    newkey = getZone(newlocation)

    IO.inspect(Registry.values(Registry.IotApp, oldkey, self()), label: "old location")
    Registry.unregister(Registry.IotApp, oldkey)
    Registry.register(Registry.IotApp, newkey, newlocation)
    IO.inspect(Registry.values(Registry.IotApp, newkey, self()), label: "new location")
    {:ok, str} = Jason.encode(%{"action" => "ack"})
    {:reply, {:text, str}, {newkey, newlocation}}
  end


  def wakeupNeighbors(key, location) do
    # this function have same PID that the websocket_init() function
    IO.puts("-------------wakeupNeighbors--------------")
    {:ok, message} = Jason.encode(%{"action" => "report_status"})

    Registry.IotApp
    |> Registry.dispatch(key, fn entries ->
      for {pid, neighbor} <- entries do
        IO.inspect(neighbor, label: "neighbor location")

        if pid != self() && isNeighbour(location, neighbor) do
          IO.inspect(pid, label: "      send msg to")
          Process.send(pid, message, [])
        end
      end
    end)

    {:ok, str} = Jason.encode(%{"action" => "ack"})
    {:text, str}
  end

  def isNeighbour(location, neighbor) do
    # @degrees > distanceEuclidean(location,neighbor)
    @meters > distanceHaversine(location, neighbor)
  end

  def distanceEuclidean({cx, cy}, {nx, ny}) do
    :math.sqrt(:math.pow(abs(cx - nx), 2) + :math.pow(abs(cy - ny), 2))
  end

  def distanceHaversine({cx, cy}, {nx, ny}) do
    Geocalc.distance_between([cx, cy], [nx, ny])
  end

  def getZone({lon, lat}) do
    {:ok, coord} = Geocoder.call({lat, lon}, provider: Geocoder.Providers.OpenStreetMaps)

    # OpenStreetMaps is only for testing, it is limited to 1 request by second.

    key = "#{coord.location.state}, #{coord.location.city}"
    IO.inspect(key, label: "getZone")
    key
  end

end