def main():
ns = OTNS()
ns.web()
ns.speed = float('inf')
while True:
# wait until next time
for n in (2, 3, 4, 5, 6, 7, 8):
test_nxn(ns, n)
time.sleep(1)
def __init__(self, name, headers, raw=False):
self.name = name
self._otns_args = []
if raw:
self._otns_args.append('-raw')
self.ns = OTNS(otns_args=self._otns_args)
self.ns.speed = float('inf')
self.ns.web()
self.result = StressTestResult(name=name, headers=headers)
self.result.start()
def testWithOTNS(self):
"""
make sure OTNS works in with-statement
"""
self.tearDown()
with OTNS(otns_args=['-log', 'debug']) as ns:
ns.add("router")
# run a second time to make sure the previous simulation is properly terminated
with OTNS(otns_args=['-log', 'debug']) as ns:
ns.add("router")
def setUp(self):
"""Test method set up.
"""
self.ns = OTNS(otns_args=[
"-raw", "-real", "-ot-cli", "otns-silk-proxy", "-listen", ":9000",
"-log", "debug"
])
# wait for OTNS gRPC server to start
time.sleep(0.3)
self.manager = OtnsManager("localhost",
self.logger.getChild("OtnsManager"))
self.manager.wait_for_grpc_channel_ready(10)
def main():
ns = OTNS(otns_args=["-log", "debug"])
ns.set_title("Form Partition Example")
ns.set_network_info(version="Latest", commit="main", real=False)
ns.web()
ns.speed = float('inf')
while True:
# wait until next time
for n in (2, 3, 4, 5, 6, 7, 8):
test_nxn(ns, n)
time.sleep(1)
class OTNSTestCase(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
tracemalloc.start()
logging.basicConfig(level=logging.DEBUG)
def setUp(self) -> None:
self.ns = OTNS()
self.ns.speed = OTNS.MAX_SIMULATE_SPEED
def tearDown(self) -> None:
self.ns.close()
def assertFormPartitions(self, count: int):
pars = self.ns.partitions()
self.assertTrue(len(pars) == count and 0 not in pars, pars)
def setUp(self) -> None:
self.ns = OTNS(otns_args=[
"-raw", "-real", "-ot-cli", "otns-silk-proxy", "-listen", ":9000",
"-log", "debug"
])
# wait for OTNS gRPC server to start
time.sleep(0.3)
self.grpc_client = GRPCClient()
self.udp_signalers = {}
class OTNSTestCase(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
tracemalloc.start()
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)-15s - %(levelname)s - %(message)s')
def setUp(self) -> None:
self.ns = OTNS(otns_args=['-log', 'debug'])
self.ns.speed = OTNS.MAX_SIMULATE_SPEED
def tearDown(self) -> None:
self.ns.close()
def assertFormPartitions(self, count: int):
pars = self.ns.partitions()
self.assertTrue(len(pars) == count and 0 not in pars, pars)
def go(self, duration: float) -> None:
"""
Run the simulation for a given duration.
:param duration: the duration to simulate
"""
self.ns.go(duration)
def assertNodeState(self, nodeid: int, state: str):
cur_state = self.ns.get_state(nodeid)
self.assertEqual(
state, cur_state,
f"Node {nodeid} state mismatch: expected {state}, but is {cur_state}"
)
class BaseStressTest(object, metaclass=StressTestMetaclass):
def __init__(self, name, headers, raw=False):
self.name = name
self._otns_args = []
if raw:
self._otns_args.append('-raw')
self.ns = OTNS(otns_args=self._otns_args)
self.ns.speed = float('inf')
self.ns.web()
self.result = StressTestResult(name=name, headers=headers)
self.result.start()
def run(self):
raise NotImplementedError()
def reset(self):
nodes = self.ns.nodes()
if nodes:
self.ns.delete(*nodes.keys())
def stop(self):
self.result.stop()
self.ns.close()
def report(self):
try:
STRESS_RESULT_FILE = os.environ['STRESS_RESULT_FILE']
stress_result_fd = open(STRESS_RESULT_FILE, 'wt')
except KeyError:
stress_result_fd = sys.stdout
with stress_result_fd:
stress_result_fd.write(
f"""**[OTNS](https://github.com/openthread/ot-ns) Stress Tests Report Generated at {time.strftime(
"%m/%d %H:%M:%S")}**\n""")
stress_result_fd.write(self.result.format())
def setUp(self) -> None:
self.ns = OTNS(otns_args=['-log', 'debug'])
self.ns.speed = OTNS.MAX_SIMULATE_SPEED
def setUp(self) -> None:
self.ns = OTNS(otns_args=['-raw', '-log', 'debug'])
self.ns.speed = float('inf')
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 3. Neither the name of the copyright holder nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from otns.cli import OTNS
ns = OTNS(otns_args=["-log", "debug"])
ns.web()
ns.add("router", x=300, y=300)
ns.add("router", x=200, y=300)
ns.add("fed", x=300, y=200)
ns.add("med", x=400, y=300)
ns.add("sed", x=300, y=400)
ns.go()
def setUp(self) -> None:
self.ns = OTNS()
self.ns.speed = OTNS.MAX_SIMULATE_SPEED
class BaseStressTest(object, metaclass=StressTestMetaclass):
def __init__(self, name, headers, raw=False):
self.name = name
self._otns_args = []
if raw:
self._otns_args.append('-raw')
self.ns = OTNS(otns_args=self._otns_args)
self.ns.speed = float('inf')
self.ns.web()
self.result = StressTestResult(name=name, headers=headers)
self.result.start()
def run(self):
raise NotImplementedError()
def reset(self):
nodes = self.ns.nodes()
if nodes:
self.ns.delete(*nodes.keys())
def stop(self):
self.result.stop()
self.ns.close()
def expect_node_state(self,
nid: int,
state: str,
timeout: float,
go_step: int = 1) -> None:
while timeout > 0:
self.ns.go(go_step)
timeout -= go_step
if self.ns.get_state(nid) == state:
return
raise UnexpectedNodeState(nid, state, self.ns.get_state(nid))
def report(self):
try:
STRESS_RESULT_FILE = os.environ['STRESS_RESULT_FILE']
stress_result_fd = open(STRESS_RESULT_FILE, 'wt')
except KeyError:
stress_result_fd = sys.stdout
try:
stress_result_fd.write(
f"""**[OTNS](https://github.com/openthread/ot-ns) Stress Tests Report Generated at {time.strftime(
"%m/%d %H:%M:%S")}**\n""")
stress_result_fd.write(self.result.format())
finally:
if stress_result_fd is not sys.stdout:
stress_result_fd.close()
def avg_except_max(self, vals: Collection[float]) -> float:
assert len(vals) >= 2
max_val = max(vals)
max_idxes = [i for i in range(len(vals)) if vals[i] >= max_val]
assert max_idxes
rmidx = max_idxes[0]
vals[rmidx:rmidx + 1] = []
return self.avg(vals)
def avg(self, vals: Collection[float]) -> float:
assert len(vals) > 0
return sum(vals) / len(vals)
def expect_all_nodes_become_routers(self, timeout: int = 1000) -> None:
all_routers = False
while timeout > 0 and not all_routers:
self.ns.go(10)
timeout -= 10
nodes = (self.ns.nodes())
all_routers = True
print(nodes)
for nid, info in nodes.items():
if info['state'] not in ['leader', 'router']:
all_routers = False
break
if all_routers:
break
if not all_routers:
raise UnexpectedError("not all nodes are Routers: %s" %
self.ns.nodes())
def expect_node_addr(self, nodeid: int, addr: str, timeout=100):
addr = ipaddress.IPv6Address(addr)
found_addr = False
while timeout > 0:
if addr in map(ipaddress.IPv6Address, self.ns.get_ipaddrs(nodeid)):
found_addr = True
break
self.ns.go(1)
if not found_addr:
raise UnexpectedNodeAddr(
f'Address {addr} not found on node {nodeid}')
def expect_node_mleid(self, nodeid: int, timeout: int):
while True:
mleid = self.ns.get_mleid(nodeid)
if mleid:
return mleid
self.ns.go(1)
timeout -= 1
if timeout <= 0:
raise UnexpectedNodeAddr(f'MLEID not found on node {nodeid}')
def main():
ns = OTNS(otns_args=['-log', 'info'])
ns.speed = 1
ns.web()
gateway = ns.add("router",
FARM_RECT[0],
FARM_RECT[1],
radio_range=RECEIVER_RADIO_RANGE)
ns.add("router",
FARM_RECT[0],
FARM_RECT[3],
radio_range=RECEIVER_RADIO_RANGE)
ns.add("router",
FARM_RECT[2],
FARM_RECT[1],
radio_range=RECEIVER_RADIO_RANGE)
ns.add("router",
FARM_RECT[2],
FARM_RECT[3],
radio_range=RECEIVER_RADIO_RANGE)
ns.add("router", (FARM_RECT[0] + FARM_RECT[2]) // 2,
FARM_RECT[1],
radio_range=RECEIVER_RADIO_RANGE)
ns.add("router", (FARM_RECT[0] + FARM_RECT[2]) // 2,
FARM_RECT[3],
radio_range=RECEIVER_RADIO_RANGE)
horse_pos = {}
horse_move_dir = {}
for i in range(HORSE_NUM):
rx = random.randint(FARM_RECT[0] + 20, FARM_RECT[2] - 20)
ry = random.randint(FARM_RECT[1] + 20, FARM_RECT[3] - 20)
sid = ns.add("sed", rx, ry, radio_range=HORSE_RADIO_RANGE)
horse_pos[sid] = (rx, ry)
horse_move_dir[sid] = random.uniform(0, math.pi * 2)
def blocked(sid, x, y):
if not (FARM_RECT[0] + 20 < x < FARM_RECT[2] - 20) or not (
FARM_RECT[1] + 20 < y < FARM_RECT[3] - 20):
return True
for oid, (ox, oy) in horse_pos.items():
if oid == sid:
continue
dist2 = (x - ox)**2 + (y - oy)**2
if dist2 <= 1600:
return True
return False
time_accum = 0
while True:
dt = 1
ns.go(dt)
time_accum += dt
for sid, (sx, sy) in horse_pos.items():
for i in range(10):
mdist = random.uniform(0, 2 * R * dt)
sx = int(sx + mdist * math.cos(horse_move_dir[sid]))
sy = int(sy + mdist * math.sin(horse_move_dir[sid]))
if blocked(sid, sx, sy):
horse_move_dir[sid] += random.uniform(0, math.pi * 2)
continue
sx = min(max(sx, FARM_RECT[0]), FARM_RECT[2])
sy = min(max(sy, FARM_RECT[1]), FARM_RECT[3])
ns.move(sid, sx, sy)
horse_pos[sid] = (sx, sy)
break
if time_accum >= 10:
for sid in horse_pos:
ns.ping(sid, gateway)
time_accum -= 10
class OTNSIntegrationTest(SilkTestCase):
"""Silk integration test case for OTNS.
"""
def setUp(self):
"""Test method set up.
"""
self.ns = OTNS(otns_args=[
"-raw", "-real", "-ot-cli", "otns-silk-proxy", "-listen", ":9000",
"-log", "debug"
])
# wait for OTNS gRPC server to start
time.sleep(0.3)
self.manager = OtnsManager("localhost",
self.logger.getChild("OtnsManager"))
self.manager.wait_for_grpc_channel_ready(10)
def tearDown(self) -> None:
"""Test method tear down.
"""
self.manager.unsubscribe_from_all_nodes()
self.manager.remove_all_nodes()
self.ns.close()
# wait for OTNS gRPC server to stop
time.sleep(0.2)
def assert_device_positions(self, nodes_info: Dict[int, Dict[str, Any]],
expected_coords: Dict[int, Tuple[int, int]]):
"""Helper method to assert auto layout position devices coordinates.
Args:
nodes_info (Dict[int, Dict[str, Any]]): nodes info dictionary.
expected_coords (Dict[int, Tuple[int, int]]): dict mapping device id to coordinates to check.
"""
for device_id, coords in expected_coords.items():
self.assertAlmostEqual(nodes_info[device_id]["x"],
coords[0],
delta=1)
self.assertAlmostEqual(nodes_info[device_id]["y"],
coords[1],
delta=1)
def testAddDevice(self):
"""Test adding device.
"""
ns = self.ns
manager = self.manager
device = MockThreadDevBoard(1)
manager.add_node(device)
ns.go(0.1)
self.assertEqual(len(ns.nodes()), 1)
def testRemoveDevice(self):
"""Test removing device.
"""
ns = self.ns
manager = self.manager
device = MockThreadDevBoard(1)
manager.add_node(device)
ns.go(0.1)
self.assertEqual(len(ns.nodes()), 1)
manager.remove_node(device)
ns.go(0.1)
self.assertEqual(len(ns.nodes()), 0)
def testSetSpeed(self):
"""Test setting speed display.
"""
ns = self.ns
manager = self.manager
speed = random.randint(2, 20)
manager.set_replay_speed(speed)
self.assertAlmostEqual(ns.speed, speed)
speed = random.randint(21, 40)
manager.set_replay_speed(speed)
self.assertAlmostEqual(ns.speed, speed)
def testAddFixedPositionDevices(self):
"""Test adding fixed position nodes.
"""
def assert_device_fixed_positions(devices: List[MockThreadDevBoard]):
"""Helper method to assert fixed position devices coordinates.
Args:
devices (List[MockThreadDevBoard]): list of devices to check.
"""
for a_device in devices:
self.assertEqual(nodes_info[a_device.id]["x"], a_device.x)
self.assertEqual(nodes_info[a_device.id]["y"], a_device.y)
ns = self.ns
manager = self.manager
device_1 = MockThreadDevBoard(random.randint(1, 10))
device_2 = MockThreadDevBoard(random.randint(11, 20))
device_3 = MockThreadDevBoard(random.randint(21, 30))
for device in [device_1, device_2, device_3]:
device.device.set_otns_vis_position(random.randint(100, 200),
random.randint(100, 200))
manager.add_node(device_1)
manager.add_node(device_2)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 2)
assert_device_fixed_positions([device_1, device_2])
manager.add_node(device_3)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 3)
assert_device_fixed_positions([device_1, device_2, device_3])
def testAddAutoLayoutDevices(self):
"""Test adding auto layout nodes.
"""
ns = self.ns
manager = self.manager
layout_center_x = random.randint(100, 200)
layout_center_y = random.randint(100, 200)
layout_radius = random.randint(50, 100)
device_1 = MockThreadDevBoard(1)
device_2 = MockThreadDevBoard(2)
device_3 = MockThreadDevBoard(3)
device_4 = MockThreadDevBoard(4)
for device in [device_1, device_2, device_3, device_4]:
device.device.set_otns_layout_parameter(layout_center_x,
layout_center_y,
layout_radius)
manager.add_node(device_1)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 1)
# placing the first node alone
expected_coords = {
device_1.id: (layout_center_x + layout_radius, layout_center_y)
}
nodes_info = ns.nodes()
self.assert_device_positions(nodes_info, expected_coords)
manager.add_node(device_2)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 2)
# forming a horizontal line
expected_coords = {
device_1.id: (layout_center_x - layout_radius, layout_center_y),
device_2.id: (layout_center_x + layout_radius, layout_center_y)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.add_node(device_3)
manager.add_node(device_4)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 4)
# forming a cross shape
expected_coords = {
device_1.id: (layout_center_x, layout_center_y + layout_radius),
device_2.id: (layout_center_x - layout_radius, layout_center_y),
device_3.id: (layout_center_x, layout_center_y - layout_radius),
device_4.id: (layout_center_x + layout_radius, layout_center_y)
}
self.assert_device_positions(nodes_info, expected_coords)
def testRemoveAutoLayoutDevices(self):
"""Test that removing nodes keeps other nodes stationary with auto layout.
"""
ns = self.ns
manager = self.manager
layout_center_x = random.randint(100, 200)
layout_center_y = random.randint(100, 200)
layout_radius = random.randint(50, 100)
device_1 = MockThreadDevBoard(1)
device_2 = MockThreadDevBoard(2)
device_3 = MockThreadDevBoard(3)
device_4 = MockThreadDevBoard(4)
for device in [device_1, device_2, device_3, device_4]:
device.device.set_otns_layout_parameter(layout_center_x,
layout_center_y,
layout_radius)
manager.add_node(device)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 4)
expected_coords = {
device_1.id: (layout_center_x, layout_center_y + layout_radius),
device_2.id: (layout_center_x - layout_radius, layout_center_y),
device_3.id: (layout_center_x, layout_center_y - layout_radius),
device_4.id: (layout_center_x + layout_radius, layout_center_y)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.remove_node(device_4)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 3)
expected_coords = {
device_1.id: (layout_center_x, layout_center_y + layout_radius),
device_2.id: (layout_center_x - layout_radius, layout_center_y),
device_3.id: (layout_center_x, layout_center_y - layout_radius)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.remove_node(device_3)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 2)
expected_coords = {
device_1.id: (layout_center_x, layout_center_y + layout_radius),
device_2.id: (layout_center_x - layout_radius, layout_center_y)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.remove_node(device_2)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 1)
expected_coords = {
device_1.id: (layout_center_x, layout_center_y + layout_radius)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.add_node(device_2)
manager.remove_node(device_1)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 1)
expected_coords = {
device_2.id: (layout_center_x - layout_radius, layout_center_y)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.add_node(device_3)
manager.remove_node(device_2)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 1)
expected_coords = {
device_3.id: (layout_center_x, layout_center_y - layout_radius)
}
self.assert_device_positions(nodes_info, expected_coords)
manager.add_node(device_4)
manager.remove_node(device_3)
ns.go(0.1)
nodes_info = ns.nodes()
self.assertEqual(len(nodes_info), 1)
expected_coords = {
device_4.id: (layout_center_x + layout_radius, layout_center_y)
}
self.assert_device_positions(nodes_info, expected_coords)
def testUpdateExtaddr(self):
"""Test updating node extended address.
Also tests updating before the OTNS manager subscribes to the node.
"""
ns = self.ns
manager = self.manager
device_extaddr = random.getrandbits(64)
device = MockThreadDevBoard(random.randint(1, 10))
manager.add_node(device)
ns.go(0.1)
self.assertEqual(ns.nodes()[device.id]["extaddr"], device.id)
device.wpantund_process.emit_status(f"extaddr={device_extaddr:016x}")
ns.go(0.1)
self.assertEqual(ns.nodes()[device.id]["extaddr"], device.id)
manager.subscribe_to_node(device)
device.wpantund_process.emit_status(f"extaddr={device_extaddr:016x}")
ns.go(0.1)
self.assertEqual(ns.nodes()[device.id]["extaddr"], device_extaddr)
def testUpdateRLOC16(self):
"""Test updating node RLOC16.
Also tests updating before the OTNS manager subscribes to the node.
"""
ns = self.ns
manager = self.manager
device_rloc16 = random.getrandbits(16)
device = MockThreadDevBoard(random.randint(1, 10))
manager.add_node(device)
ns.go(0.1)
original_rloc16 = ns.nodes()[device.id]["rloc16"]
device.wpantund_process.emit_status(f"rloc16={device_rloc16}")
ns.go(0.1)
self.assertEqual(ns.nodes()[device.id]["rloc16"], original_rloc16)
manager.subscribe_to_node(device)
device.wpantund_process.emit_status(f"rloc16={device_rloc16}")
ns.go(0.1)
self.assertEqual(ns.nodes()[device.id]["rloc16"], device_rloc16)
def testFormPartition(self):
"""Test forming a partition.
"""
ns = self.ns
manager = self.manager
device_1_parid = random.getrandbits(16)
device_1 = MockThreadDevBoard(random.randint(1, 10))
device_2_parid = random.getrandbits(16)
device_2 = MockThreadDevBoard(random.randint(11, 20))
manager.add_node(device_1)
manager.add_node(device_2)
manager.subscribe_to_node(device_1)
manager.subscribe_to_node(device_2)
device_1.wpantund_process.emit_status(f"parid={device_1_parid:08x}")
device_2.wpantund_process.emit_status(f"parid={device_2_parid:08x}")
ns.go(0.1)
partitions_info = ns.partitions()
self.assertEqual(len(partitions_info), 2)
self.assertEqual(len(partitions_info[device_1_parid]), 1)
self.assertEqual(len(partitions_info[device_2_parid]), 1)
self.assertEqual(partitions_info[device_1_parid][0], device_1.id)
self.assertEqual(partitions_info[device_2_parid][0], device_2.id)
device_2.wpantund_process.emit_status(f"parid={device_1_parid:08x}")
ns.go(0.1)
partitions_info = ns.partitions()
self.assertEqual(len(partitions_info), 1)
self.assertEqual(len(partitions_info[device_1_parid]), 2)
self.assertIn(device_1.id, partitions_info[device_1_parid])
self.assertIn(device_2.id, partitions_info[device_1_parid])
device_2.wpantund_process.emit_status(f"parid={device_2_parid:08x}")
ns.go(0.1)
partitions_info = ns.partitions()
self.assertEqual(len(partitions_info), 2)
self.assertEqual(len(partitions_info[device_1_parid]), 1)
self.assertEqual(len(partitions_info[device_2_parid]), 1)
self.assertEqual(partitions_info[device_1_parid][0], device_1.id)
self.assertEqual(partitions_info[device_2_parid][0], device_2.id)
def main():
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s',
level=logging.DEBUG)
ns = OTNS()
ns.set_title("Ping Example")
ns.set_network_info(version="Latest", commit="master", real=False)
ns.web()
ns.speed = 4
def add_node(*args, **kwargs):
return ns.add(*args, **kwargs, radio_range=RADIO_RANGE)
add_node("fed", 100, 100)
add_node("fed", 100, 300)
add_node("fed", 100, 500)
add_node("fed", 100, 700)
add_node("fed", 100, 900)
add_node("router", 450, 100)
add_node("router", 550, 300)
add_node("router", 450, 500)
add_node("router", 550, 700)
add_node("router", 450, 900)
add_node("fed", 1800, 100)
add_node("fed", 1800, 300)
add_node("fed", 1800, 500)
add_node("fed", 1800, 700)
add_node("fed", 1800, 900)
add_node("router", 1450, 100)
add_node("router", 1350, 300)
add_node("router", 1450, 500)
add_node("router", 1350, 700)
add_node("router", 1450, 900)
C1 = add_node("router", 950, 300)
C2 = add_node("router", 800, 700)
C3 = add_node("router", 1100, 700)
def ping(src: int, dst: int, duration: float):
while duration > 0:
ns.ping(src, dst)
ns.go(1)
duration -= 1
while True:
ping(1, 11, 30)
c1_rlocs = ns.get_ipaddrs(C1, "rloc")
if c1_rlocs:
for i in range(4):
for id in (6, 7, 8, 9, 16, 17, 18, 19, C2, C3):
ns.ping(id, c1_rlocs[0])
ns.delete(C1)
ping(1, 11, 30)
ns.delete(C2)
ns.delete(C3)
ns.go(130)
add_node("router", 950, 300, id=C1)
add_node("router", 800, 700, id=C2)
add_node("router", 1100, 700, id=C3)
ns.go(10)
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import logging
from otns.cli import OTNS
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s',
level=logging.DEBUG)
ns = OTNS()
ns.web()
RADIO_RANGE = 460
ns.speed = 4
def add_node(*args, **kwargs):
return ns.add(*args, **kwargs, radio_range=RADIO_RANGE)
add_node("fed", 100, 100)
add_node("fed", 100, 300)
add_node("fed", 100, 500)
add_node("fed", 100, 700)
def main():
ns = OTNS(otns_args=["-log", "debug"])
ns.set_title("Simple Example")
ns.set_network_info(version="Latest", commit="main", real=False)
ns.web()
ns.add("router", x=300, y=300)
ns.add("router", x=200, y=300)
ns.add("fed", x=300, y=200)
ns.add("med", x=400, y=300)
ns.add("sed", x=300, y=400)
ns.go()
