145 lines
4.5 KiB
Elixir
145 lines
4.5 KiB
Elixir
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
|