402 lines
11 KiB
Elixir
402 lines
11 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 find_by_name(pid, table, name) do
|
|
GenServer.call(pid, {:find_by_name, table, name})
|
|
end
|
|
|
|
# API functions
|
|
|
|
@doc """
|
|
Create a bridge:
|
|
|
|
## options:
|
|
iex> OpenvSwitch.add_br(
|
|
client_pid,
|
|
name: "br0",
|
|
fail_mode: "standalone",
|
|
datapath_id: "0000000000000001",
|
|
disable_in_band: "true"
|
|
)
|
|
"""
|
|
def add_br(pid, [_|_] = options) do
|
|
br_uuids = GenServer.call(pid, {:sync_get, @open_vswitch, "bridges"})
|
|
|
|
add_br_options = [
|
|
bridge: options[:name],
|
|
fail_mode: options[:fail_mode] || "standalone",
|
|
datapath_id: options[:datapath_id],
|
|
disable_in_band: options[:disable_in_band],
|
|
br_uuids: br_uuids
|
|
]
|
|
|
|
GenServer.call(pid, {:add_br, add_br_options})
|
|
end
|
|
|
|
@doc """
|
|
Delete a bridge
|
|
|
|
iex> OpenvSwitch.del_br(client_pid, "br0")
|
|
"""
|
|
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
|
|
|
|
@doc """
|
|
Set a controller to the switch
|
|
|
|
iex> OpenvSwitch.set_controller(
|
|
client_pid,
|
|
bridge: "br0",
|
|
target: "tcp:127.0.0.1:6653",
|
|
connection_mode: "out-of-band",
|
|
controller_rate_limit: 100,
|
|
controller_burst_limit: 25,
|
|
protocol: "OpenFlow13"
|
|
)
|
|
"""
|
|
def set_controller(pid, [_|_] = options) do
|
|
case find_by_name(pid, @bridge, options[:bridge]) do
|
|
:not_found ->
|
|
{:error, :not_found}
|
|
%{"_uuid" => _uuid} ->
|
|
set_ctl_opts = [
|
|
bridge: options[:bridge],
|
|
target: options[:target] || "tcp:127.0.0.1:6653",
|
|
connection_mode: options[:connection_mode] || "out-of-band",
|
|
controller_rate_limit: options[:controller_rate_limit] || 1000,
|
|
controller_burst_limit: options[:controller_burst_limit] || 100,
|
|
protocol: options[:protocol] || "OpenFlow13",
|
|
]
|
|
|
|
GenServer.call(pid, {:set_controller, set_ctl_opts})
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
iex> OpenvSwitch.add_port(
|
|
client_pid,
|
|
bridge: "br0",
|
|
name: "vxlan5",
|
|
type: "vxlan",
|
|
remote_ip: "flow",
|
|
ofport_request: 99
|
|
)
|
|
"""
|
|
def add_port(pid, [_|_] = options) do
|
|
case find_by_name(pid, @bridge, options[:bridge]) do
|
|
:not_found ->
|
|
{:error, :not_found}
|
|
%{"_uuid" => _uuid, "ports" => ports} ->
|
|
port_opts = [
|
|
bridge: options[:bridge],
|
|
name: options[:name],
|
|
type: options[:type] || "system",
|
|
ofport_request: options[:ofport_request],
|
|
remote_ip: options[:remote_ip],
|
|
local_ip: options[:local_ip],
|
|
in_key: options[:in_key],
|
|
out_key: options[:out_key],
|
|
key: options[:key],
|
|
tos: options[:tos],
|
|
ttl: options[:ttl],
|
|
df_default: options[:df_default],
|
|
csum: options[:csum],
|
|
peer_cert: options[:peer_cert],
|
|
certificate: options[:certificate],
|
|
private_key: options[:private_key],
|
|
psk: options[:psk],
|
|
ingress_policing_rate: options[:ingress_policing_rate] || 0,
|
|
ingress_policing_burst: options[:ingress_policing_burst] || 0,
|
|
ports: ports
|
|
]
|
|
|
|
GenServer.call(pid, {:add_port, port_opts})
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
iex> OpenvSwitch.del_port(client_pid, bridge: "br0", port: "vxlan5")
|
|
"""
|
|
def del_port(pid, [_|_] = options) do
|
|
case find_by_name(pid, @bridge, options[:bridge]) do
|
|
:not_found ->
|
|
{:error, :not_found}
|
|
%{"_uuid" => _uuid, "ports" => ports} ->
|
|
case find_by_name(pid, @port, options[:port]) do
|
|
:not_found ->
|
|
{:error, :not_found}
|
|
%{"_uuid" => port_uuid} ->
|
|
new_ports = del_elem_from_set(ports, port_uuid)
|
|
|
|
port_opts = [
|
|
bridge: options[:bridge],
|
|
ports: new_ports
|
|
]
|
|
|
|
GenServer.call(pid, {:del_port, port_opts})
|
|
end
|
|
end
|
|
end
|
|
|
|
# GenServer callback functions
|
|
|
|
def start_link(server) do
|
|
GenServer.start_link(__MODULE__, [server])
|
|
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"]}
|
|
|
|
other_config = [
|
|
["datapath-id", options[:datapath_id]],
|
|
["dp-desc", options[:dp_desc]],
|
|
["disable-in-band", options[:disable_in_band]],
|
|
["in-band-queue", options[:in_band_queue]]
|
|
]
|
|
|
|
new_bridge = %{
|
|
name: options[:bridge],
|
|
ports: ["named-uuid", "brport"],
|
|
fail_mode: options[:fail_mode],
|
|
other_config: make_ovsdb_map(other_config)
|
|
}
|
|
|
|
named_uuid = ["named-uuid", "bridge"]
|
|
|
|
new_bridges = add_elem_to_set(options[:br_uuids], named_uuid)
|
|
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(@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({:del_port, options}, _from, state) do
|
|
%State{client_pid: pid, ovs_uuid: ovs} = state
|
|
eq_br_name = [{"name", "==", options[:bridge]}]
|
|
eq_ovs_uuid = [{"_uuid", "==", ovs}]
|
|
next_config = [{"next_cfg", "+=", 1}]
|
|
|
|
bridge = %{ports: options[:ports]}
|
|
|
|
replies =
|
|
xact([
|
|
:eovsdb_op.update(@bridge, eq_br_name, bridge),
|
|
:eovsdb_op.mutate(@open_vswitch, eq_ovs_uuid, next_config)
|
|
], pid)
|
|
|
|
{:reply, replies, state}
|
|
end
|
|
|
|
def handle_call({:set_controller, options}, _from, state) do
|
|
%State{client_pid: pid, ovs_uuid: ovs} = state
|
|
controller = %{
|
|
target: options[:target],
|
|
connection_mode: options[:connection_mode],
|
|
controller_rate_limit: options[:controller_rate_limit],
|
|
controller_burst_limit: options[:controller_burst_limit],
|
|
}
|
|
|
|
bridge = %{
|
|
protocols: options[:protocol],
|
|
controller: ["named-uuid", "controller"],
|
|
}
|
|
|
|
replies =
|
|
xact([
|
|
:eovsdb_op.insert(@controller, controller, "controller"),
|
|
:eovsdb_op.update(@bridge, [{"name", "==", options[:bridge]}], bridge),
|
|
:eovsdb_op.mutate(@open_vswitch, [{"_uuid", "==", ovs}], [{"next_cfg", "+=", 1}])
|
|
], pid)
|
|
|
|
{:reply, replies, state}
|
|
end
|
|
|
|
def handle_call({:add_port, options}, _from, state) do
|
|
%State{client_pid: pid, ovs_uuid: ovs} = state
|
|
|
|
port = %{
|
|
name: options[:name],
|
|
interfaces: ["named-uuid", "interface"],
|
|
}
|
|
|
|
iface_options = [
|
|
["remote_ip", options[:remote_ip]],
|
|
["local_ip", options[:local_ip]],
|
|
["in_key", options[:in_key]],
|
|
["out_key", options[:out_key]],
|
|
["key", options[:key]],
|
|
["tos", options[:tos]],
|
|
["ttl", options[:ttl]],
|
|
["df_default", options[:df_default]],
|
|
["csum", options[:csum]],
|
|
["peer_cert", options[:peer_cert]],
|
|
["certificate", options[:certificate]],
|
|
["private_key", options[:private_key]],
|
|
["psk", options[:psk]]
|
|
]
|
|
|
|
interface = %{
|
|
name: options[:name],
|
|
type: options[:type],
|
|
ingress_policing_rate: options[:ingress_policing_rate],
|
|
ingress_policing_burst: options[:ingress_policing_burst],
|
|
ofport_request: make_ovsdb_set(options[:ofport_request]),
|
|
options: make_ovsdb_map(iface_options)
|
|
}
|
|
|
|
bridge = %{ports: add_elem_to_set(options[:ports], ["named-uuid", "port"])}
|
|
|
|
next_config = [{"next_cfg", "+=", 1}]
|
|
eq_br_name = [{"name", "==", options[:bridge]}]
|
|
eq_ovs_uuid = [{"_uuid", "==", ovs}]
|
|
|
|
replies =
|
|
xact(
|
|
[
|
|
:eovsdb_op.insert(@interface, interface, "interface"),
|
|
:eovsdb_op.insert(@port, port, "port"),
|
|
:eovsdb_op.update(@bridge, eq_br_name, bridge),
|
|
: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
|
|
reply = do_find_by_name(pid, table, name)
|
|
{: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
|
|
|
|
defp do_find_by_name(pid, table, name) do
|
|
query = :eovsdb_op.select('*', table, [{"name", "==", name}])
|
|
case xact(query, pid) do
|
|
[%{"rows" => []}] -> :not_found
|
|
[%{"rows" => [row]}] -> row
|
|
end
|
|
end
|
|
|
|
defp make_ovsdb_map(map), do: make_ovsdb_map([], map)
|
|
|
|
defp make_ovsdb_map(acc, []), do: ["map", Enum.reverse(acc)]
|
|
defp make_ovsdb_map(acc, [[_key, nil]|rest]), do: make_ovsdb_map(acc, rest)
|
|
defp make_ovsdb_map(acc, [attr|rest]), do: make_ovsdb_map([attr|acc], rest)
|
|
|
|
defp make_ovsdb_set(nil), do: ["set", []]
|
|
defp make_ovsdb_set([_|_] = list), do: ["set", list]
|
|
defp make_ovsdb_set(value), do: value
|
|
|
|
defp add_elem_to_set(["set", []], value), do: value
|
|
defp add_elem_to_set(["set", values], value), do: ["set", values ++ value]
|
|
defp add_elem_to_set(["uuid", _] = uuid, value), do: ["set", [uuid] ++ [value]]
|
|
|
|
defp del_elem_from_set(["set", values], value), do: ["set", values -- [value]]
|
|
defp del_elem_from_set(["uuid", _], _value), do: ["set", []]
|
|
end
|