Implement an Open_vSwitch configuration module

lib/ovsdb/open_vswitch.ex

@@ -0,0 +1,145 @@
+defmodule OVSDB.OpenvSwitch do
+  use GenServer
+
+  defmodule State do
+    defstruct [
+      server:      nil,
+      client_pid:  nil,
+      monitor_pid: nil,
+      ovs_uuid:    nil
+    ]
+  end
+
+  @database "Open_vSwitch"
+
+  @open_vswitch "Open_vSwitch"
+  @interface    "Interface"
+  @port         "Port"
+  @controller   "Controller"
+  @bridge       "Bridge"
+
+  def start_link(server) do
+    GenServer.start_link(__MODULE__, [server])
+  end
+
+  def find_by_name(pid, table, name) do
+    GenServer.call(pid, {:find_by_name, table, name})
+  end
+
+  def add_br(pid, bridge, options \\ []) do
+    br_uuids = GenServer.call(pid, {:sync_get, @open_vswitch, "bridges"})
+    add_br_options = [
+      bridge:     bridge,
+      controller: options[:controller] || "tcp:127.0.0.1:6653",
+      protocol:   options[:protocol] || "OpenFlow13",
+      fail_mode:  options[:fail_mode] || "standalone",
+      br_uuids:   br_uuids
+    ]
+    GenServer.call(pid, {:add_br, add_br_options})
+  end
+
+  def del_br(pid, bridge) do
+    case find_by_name(pid, @bridge, bridge) do
+      %{"_uuid" => uuid} ->
+        new_bridges =
+          case GenServer.call(pid, {:sync_get, @open_vswitch, "bridges"}) do
+            ["set", bridges] -> %{"bridges" => ["set", bridges -- [uuid]]}
+            ^uuid            -> %{"bridges" => ["set", []]}
+            curr_bridges     -> %{"bridges" => curr_bridges}
+          end
+        GenServer.call(pid, {:del_br, new_bridges})
+      :not_found ->
+        {:error, :not_found}
+    end
+  end
+
+  def init([server]) do
+    state = server
+    |> String.to_charlist
+    |> init_client
+    {:ok, state}
+  end
+
+  def handle_call({:sync_get, table, col_name}, _from, state) do
+    [%{"rows" => [%{^col_name => values}|_]}] =
+      [col_name]
+      |> :eovsdb_op.select(table, [])
+      |> xact(state.client_pid)
+    {:reply, values, state}
+  end
+  def handle_call({:add_br, options}, _from, state) do
+    %State{client_pid: pid, ovs_uuid: ovs} = state
+    br_iface = %{name: options[:bridge], type: :internal}
+    br_port = %{name: options[:bridge], interfaces: ["named-uuid", "brinterface"]}
+    controller = %{target: options[:controller]}
+    new_bridge = %{
+      name:       options[:bridge],
+      ports:      ["named-uuid", "brport"],
+      controller: ["named-uuid", "brcontroller"],
+      fail_mode:  options[:fail_mode],
+      protocols:  options[:protocol]
+    }
+    named_uuid = ["named-uuid", "bridge"]
+    new_bridges =
+      case options[:br_uuids] do
+        ["set", []]          -> %{bridges: named_uuid}
+        ["set", bridges]     -> %{bridges: ["set", bridges ++ [named_uuid]]}
+        ["uuid", _] = bridge -> %{bridges: ["set", [bridge] ++ [named_uuid]]}
+      end
+    next_config = [{"next_cfg", "+=", 1}]
+    eq_ovs_uuid = [{"_uuid", "==", ovs}]
+    replies = xact([
+      :eovsdb_op.insert(@interface, br_iface, "brinterface"),
+      :eovsdb_op.insert(@port, br_port, "brport"),
+      :eovsdb_op.insert(@controller, controller, "brcontroller"),
+      :eovsdb_op.insert(@bridge, new_bridge, "bridge"),
+      :eovsdb_op.update(@open_vswitch, eq_ovs_uuid, new_bridges),
+      :eovsdb_op.mutate(@open_vswitch, eq_ovs_uuid, next_config)
+    ], pid)
+    {:reply, replies, state}
+  end
+  def handle_call({:del_br, new_bridges}, _from, state) do
+    %State{client_pid: pid, ovs_uuid: ovs} = state
+    eq_ovs_uuid = [{"_uuid", "==", ovs}]
+    next_config = [{"next_cfg", "+=", 1}]
+    replies = xact([
+      :eovsdb_op.update(@open_vswitch, eq_ovs_uuid, new_bridges),
+      :eovsdb_op.mutate(@open_vswitch, eq_ovs_uuid, next_config)
+    ], pid)
+    {:reply, replies, state}
+  end
+  def handle_call({:find_by_name, table, name}, _from, state) do
+    %State{client_pid: pid} = state
+    query = :eovsdb_op.select('*', table, [{"name", "==", name}])
+    reply = case xact(query, pid) do
+              [%{"rows" => []}] -> :not_found
+              [%{"rows" => [row]}] -> row
+            end
+    {:reply, reply, state}
+  end
+
+  def handle_cast({:async_get, "_uuid"}, state) do
+    [%{"rows" => [%{"_uuid" => values}|_]}] =
+      ["_uuid"]
+      |> :eovsdb_op.select(@open_vswitch, [])
+      |> xact(state.client_pid)
+    {:noreply, %{state|ovs_uuid: values}}
+  end
+
+  # private functions
+
+  defp init_client(server) do
+    {:ok, pid} = :eovsdb_client.connect(server, [database: @database])
+    :eovsdb_client.regist_schema(pid)
+    :ok = GenServer.cast(self(), {:async_get, "_uuid"})
+    %State{server: server, client_pid: pid}
+  end
+
+  defp xact(query, pid) when is_list(query) do
+    {:ok, res} = :eovsdb_client.transaction(pid, query)
+    res
+  end
+  defp xact(query, pid) when is_map(query) do
+    xact([query], pid)
+  end
+end