def test_add_link_exception(self, grpc_server: CoreGrpcServer,
interface_helper: InterfaceHelper):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
node = session.add_node(CoreNode)
# then
interface = interface_helper.create_interface(node.id, 0)
with pytest.raises(grpc.RpcError):
with client.context_connect():
client.add_link(session.id, 1, 3, interface)
def test_add_link(self, grpc_server: CoreGrpcServer, iface_helper: InterfaceHelper):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
switch = session.add_node(SwitchNode)
node = session.add_node(CoreNode)
assert len(switch.links()) == 0
# then
iface = iface_helper.create_iface(node.id, 0)
with client.context_connect():
response = client.add_link(session.id, node.id, switch.id, iface)
# then
assert response.result is True
assert len(switch.links()) == 1
def test_add_link(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
switch = session.add_node(SwitchNode)
node = session.add_node(CoreNode)
assert len(switch.links()) == 0
iface = InterfaceHelper("10.0.0.0/24").create_iface(node.id, 0)
link = Link(node.id, switch.id, iface1=iface)
# then
with client.context_connect():
result, iface1, _ = client.add_link(session.id, link)
# then
assert result is True
assert len(switch.links()) == 1
assert iface1.id == iface.id
assert iface1.ip4 == iface.ip4
def interface_helper():
return InterfaceHelper(ip4_prefix="10.83.0.0/16")
def test_start_session(self, grpc_server):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
position = core_pb2.Position(x=50, y=100)
node_one = core_pb2.Node(id=1, position=position, model="PC")
position = core_pb2.Position(x=100, y=100)
node_two = core_pb2.Node(id=2, position=position, model="PC")
position = core_pb2.Position(x=200, y=200)
wlan_node = core_pb2.Node(id=3,
type=NodeTypes.WIRELESS_LAN.value,
position=position)
nodes = [node_one, node_two, wlan_node]
interface_helper = InterfaceHelper(ip4_prefix="10.83.0.0/16")
interface_one = interface_helper.create_interface(node_one.id, 0)
interface_two = interface_helper.create_interface(node_two.id, 0)
link = core_pb2.Link(
type=core_pb2.LinkType.WIRED,
node_one_id=node_one.id,
node_two_id=node_two.id,
interface_one=interface_one,
interface_two=interface_two,
)
links = [link]
hook = core_pb2.Hook(state=core_pb2.SessionState.RUNTIME,
file="echo.sh",
data="echo hello")
hooks = [hook]
location_x = 5
location_y = 10
location_z = 15
location_lat = 20
location_lon = 30
location_alt = 40
location_scale = 5
location = core_pb2.SessionLocation(
x=location_x,
y=location_y,
z=location_z,
lat=location_lat,
lon=location_lon,
alt=location_alt,
scale=location_scale,
)
emane_config_key = "platform_id_start"
emane_config_value = "2"
emane_config = {emane_config_key: emane_config_value}
model_node_id = 20
model_config_key = "bandwidth"
model_config_value = "500000"
model_config = core_pb2.EmaneModelConfig(
node_id=model_node_id,
interface_id=-1,
model=EmaneIeee80211abgModel.name,
config={model_config_key: model_config_value},
)
model_configs = [model_config]
wlan_config_key = "range"
wlan_config_value = "333"
wlan_config = core_pb2.WlanConfig(
node_id=wlan_node.id, config={wlan_config_key: wlan_config_value})
wlan_configs = [wlan_config]
mobility_config_key = "refresh_ms"
mobility_config_value = "60"
mobility_config = core_pb2.MobilityConfig(
node_id=wlan_node.id,
config={mobility_config_key: mobility_config_value})
mobility_configs = [mobility_config]
service_config = core_pb2.ServiceConfig(node_id=node_one.id,
service="DefaultRoute",
validate=["echo hello"])
service_configs = [service_config]
service_file_config = core_pb2.ServiceFileConfig(
node_id=node_one.id,
service="DefaultRoute",
file="defaultroute.sh",
data="echo hello",
)
service_file_configs = [service_file_config]
# when
with patch.object(CoreXmlWriter, "write"):
with client.context_connect():
client.start_session(
session.id,
nodes,
links,
location,
hooks,
emane_config,
model_configs,
wlan_configs,
mobility_configs,
service_configs,
service_file_configs,
)
# then
assert node_one.id in session.nodes
assert node_two.id in session.nodes
assert wlan_node.id in session.nodes
assert session.nodes[node_one.id].netif(0) is not None
assert session.nodes[node_two.id].netif(0) is not None
hook_file, hook_data = session._hooks[core_pb2.SessionState.RUNTIME][0]
assert hook_file == hook.file
assert hook_data == hook.data
assert session.location.refxyz == (location_x, location_y, location_z)
assert session.location.refgeo == (location_lat, location_lon,
location_alt)
assert session.location.refscale == location_scale
assert session.emane.get_config(emane_config_key) == emane_config_value
set_wlan_config = session.mobility.get_model_config(
wlan_node.id, BasicRangeModel.name)
assert set_wlan_config[wlan_config_key] == wlan_config_value
set_mobility_config = session.mobility.get_model_config(
wlan_node.id, Ns2ScriptedMobility.name)
assert set_mobility_config[
mobility_config_key] == mobility_config_value
set_model_config = session.emane.get_model_config(
model_node_id, EmaneIeee80211abgModel.name)
assert set_model_config[model_config_key] == model_config_value
service = session.services.get_service(node_one.id,
service_config.service,
default_service=True)
assert service.validate == tuple(service_config.validate)
service_file = session.services.get_service_file(
node_one, service_file_config.service, service_file_config.file)
assert service_file.data == service_file_config.data
def test_start_session(self, grpc_server: CoreGrpcServer, definition):
# given
client = CoreGrpcClient()
with client.context_connect():
session = client.create_session()
position = Position(x=50, y=100)
node1 = session.add_node(1, position=position)
position = Position(x=100, y=100)
node2 = session.add_node(2, position=position)
position = Position(x=200, y=200)
wlan_node = session.add_node(3,
_type=NodeType.WIRELESS_LAN,
position=position)
iface_helper = InterfaceHelper(ip4_prefix="10.83.0.0/16")
iface1_id = 0
iface1 = iface_helper.create_iface(node1.id, iface1_id)
iface2_id = 0
iface2 = iface_helper.create_iface(node2.id, iface2_id)
link = Link(node1_id=node1.id,
node2_id=node2.id,
iface1=iface1,
iface2=iface2)
session.links = [link]
hook = Hook(state=SessionState.RUNTIME,
file="echo.sh",
data="echo hello")
session.hooks = {hook.file: hook}
location_x = 5
location_y = 10
location_z = 15
location_lat = 20
location_lon = 30
location_alt = 40
location_scale = 5
session.location = SessionLocation(
x=location_x,
y=location_y,
z=location_z,
lat=location_lat,
lon=location_lon,
alt=location_alt,
scale=location_scale,
)
# setup wlan config
wlan_config_key = "range"
wlan_config_value = "333"
wlan_node.set_wlan({wlan_config_key: wlan_config_value})
# setup mobility config
mobility_config_key = "refresh_ms"
mobility_config_value = "60"
wlan_node.set_mobility({mobility_config_key: mobility_config_value})
# setup service config
service_name = "DefaultRoute"
service_validate = ["echo hello"]
node1.service_configs[service_name] = NodeServiceData(
executables=[],
dependencies=[],
dirs=[],
configs=[],
startup=[],
validate=service_validate,
validation_mode=ServiceValidationMode.NON_BLOCKING,
validation_timer=0,
shutdown=[],
meta="",
)
# setup service file config
service_file = "defaultroute.sh"
service_file_data = "echo hello"
node1.service_file_configs[service_name] = {
service_file: service_file_data
}
# setup session option
option_key = "controlnet"
option_value = "172.16.0.0/24"
session.set_options({option_key: option_value})
# when
with patch.object(CoreXmlWriter, "write"):
with client.context_connect():
client.start_session(session, definition=definition)
# then
real_session = grpc_server.coreemu.sessions[session.id]
if definition:
state = EventTypes.DEFINITION_STATE
else:
state = EventTypes.RUNTIME_STATE
assert real_session.state == state
assert node1.id in real_session.nodes
assert node2.id in real_session.nodes
assert wlan_node.id in real_session.nodes
assert iface1_id in real_session.nodes[node1.id].ifaces
assert iface2_id in real_session.nodes[node2.id].ifaces
hook_file, hook_data = real_session.hooks[EventTypes.RUNTIME_STATE][0]
assert hook_file == hook.file
assert hook_data == hook.data
assert real_session.location.refxyz == (location_x, location_y,
location_z)
assert real_session.location.refgeo == (
location_lat,
location_lon,
location_alt,
)
assert real_session.location.refscale == location_scale
set_wlan_config = real_session.mobility.get_model_config(
wlan_node.id, BasicRangeModel.name)
assert set_wlan_config[wlan_config_key] == wlan_config_value
set_mobility_config = real_session.mobility.get_model_config(
wlan_node.id, Ns2ScriptedMobility.name)
assert set_mobility_config[
mobility_config_key] == mobility_config_value
service = real_session.services.get_service(node1.id,
service_name,
default_service=True)
assert service.validate == tuple(service_validate)
real_node1 = real_session.get_node(node1.id, CoreNode)
service_file = real_session.services.get_service_file(
real_node1, service_name, service_file)
assert service_file.data == service_file_data
assert option_value == real_session.options.get_config(option_key)
