diff --git a/.gitignore b/.gitignore index ee70e67..8282ddb 100644 --- a/.gitignore +++ b/.gitignore @@ -16,3 +16,6 @@ dl # Vagrant .vagrant + +venv/ +.vscode diff --git a/examples/ping-demo.py b/examples/ping-demo.py index 5db8087..dca8c55 100644 --- a/examples/ping-demo.py +++ b/examples/ping-demo.py @@ -52,14 +52,16 @@ def run(): c = topo.addHost('c') # add links - topo.addLink(a, b, delay='10ms', bw=10) # bw = bandwidth - topo.addLink(b, c, delay='10ms', bw=10) + topo.addLink(a, b, delay='10ms', bw=2.5) # bw = bandwidth + topo.addLink(b, c, delay='10ms', bw=2.5) + + info(topo.links(withInfo=True)) ndn = Minindn(topo=topo) ndn.start() # configure and start nfd on each node - info("Configuring NFD\n") + info("Configuring NFD111\n") AppManager(ndn, ndn.net.hosts, Nfd, logLevel="DEBUG") """ @@ -68,15 +70,25 @@ def run(): It can also be set manually as follows. The important bit to note here is the use of the Nfdc command """ - links = {"a":["b"], "b":["c"]} - for first in links: - for second in links[first]: - host1 = ndn.net[first] - host2 = ndn.net[second] - interface = host2.connectionsTo(host1)[0][0] - interface_ip = interface.IP() - Nfdc.createFace(host1, interface_ip) - Nfdc.registerRoute(host1, PREFIX, interface_ip, cost=0) + for link in topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + Nfdc.registerRoute(host1, PREFIX, interface_ip, cost=0) + # links = {"a":["b"], "b":["c"]} + # for first in links: + # for second in links[first]: + # host1 = ndn.net[first] + # host2 = ndn.net[second] + # interface = host2.connectionsTo(host1)[0][0] + # interface_ip = interface.IP() + # Nfdc.createFace(host1, interface_ip) + # Nfdc.registerRoute(host1, PREFIX, interface_ip, cost=0) # Start ping server info("Starting pings...\n") diff --git a/examples/qsccp-demo.py b/examples/qsccp-demo.py new file mode 100644 index 0000000..6ac3503 --- /dev/null +++ b/examples/qsccp-demo.py @@ -0,0 +1,111 @@ +# -*- Mode:python; c-file-style:"gnu"; indent-tabs-mode:nil -*- */ +# +# Copyright (C) 2015-2021, The University of Memphis, +# Arizona Board of Regents, +# Regents of the University of California. +# +# This file is part of Mini-NDN. +# See AUTHORS.md for a complete list of Mini-NDN authors and contributors. +# +# Mini-NDN is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Mini-NDN is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Mini-NDN, e.g., in COPYING.md file. +# If not, see . + +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + +PREFIX = "/A" + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + # Topology can be created/modified using Mininet topo object + topo = Topo() + info("Setup\n") + # add hosts + a = topo.addHost('a') + b = topo.addHost('b') + + # add links + topo.addLink(a, b, delay='10ms', bw=10) # bw = bandwidth + + info(topo.links(withInfo=True)) + + ndn = Minindn(topo=topo) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO") + + """ + There are multiple ways of setting up routes in Mini-NDN + refer: https://minindn.memphis.edu/experiment.html#routing-options + It can also be set manually as follows. The important bit to note here + is the use of the Nfdc command + """ + for link in topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + Nfdc.registerRoute(host1, PREFIX, interface_ip, cost=0) + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/qsccp-demo/qsccp-server.log", "w") + getPopen(ndn.net["b"], "cc-producer --prefix {}".format(PREFIX), stdout=qsccp_server_log,\ + stderr=qsccp_server_log) + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/qsccp-demo/qsccp-client.log", "w") + ping1 = getPopen(ndn.net["a"], "qsccp-client --prefix {} --timingStop 10000".format(PREFIX), stdout=qsccp_client_log, stderr=qsccp_client_log) + ping1.wait() + # printOutput(ping1.stdout.read()) + + # interface = ndn.net["b"].connectionsTo(ndn.net["a"])[0][0] + # info("Failing link\n") # failing link by setting link loss to 100% + # interface.config(delay="10ms", bw=10, loss=100) + # info ("\n starting ping2 client \n") + + # ping2 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) + # ping2.wait() + # printOutput(ping2.stdout.read()) + + # interface.config(delay="10ms", bw=10, loss=0) # bringing back the link + + info("\nExperiment Completed!\n") + MiniNDNCLI(ndn.net) + ndn.stop() + +if __name__ == '__main__': + setLogLevel("info") + run() \ No newline at end of file diff --git a/minindn/helpers/nfdc.py b/minindn/helpers/nfdc.py index 9468d8b..2009c94 100644 --- a/minindn/helpers/nfdc.py +++ b/minindn/helpers/nfdc.py @@ -76,11 +76,12 @@ class Nfdc(object): Minindn.sleep(SLEEP_TIME) @staticmethod - def createFace(node, remoteNodeAddress, protocol='udp', isPermanent=False, allowExisting=True): + def createFace(node, remoteNodeAddress, protocol='udp', isPermanent=False, allowExisting=True, bandwidth=100000000): '''Create face in node's NFD instance. Returns FaceID of created face or -1 if failed.''' - cmd = ('nfdc face create {}://{} {}'.format( + cmd = ('nfdc face create {}://{} bandwidth {} persistency {}'.format( protocol, remoteNodeAddress, + int(bandwidth), 'permanent' if isPermanent else 'persistent' )) output = node.cmd(cmd) diff --git a/minindn/minindn.py b/minindn/minindn.py index 1ba1251..05ed562 100644 --- a/minindn/minindn.py +++ b/minindn/minindn.py @@ -295,6 +295,7 @@ class Minindn(object): host.cmd('export HOME={} && cd ~'.format(homeDir)) def nfdcBatchProcessing(self, station, faces): + print("???") # Input format: [IP, protocol, isPermanent] batch_file = open("{}/{}/nfdc.batch".format(Minindn.workDir, station.name), "w") lines = [] @@ -370,5 +371,6 @@ class Minindn(object): else: created_faces[nodeB].append(nodeALink) for station_name in batch_faces.keys(): + print("========= {} =========".format(station_name)) self.nfdcBatchProcessing(self.net[station_name], batch_faces[station_name]) return created_faces \ No newline at end of file diff --git a/scenarios/qsccp1.py b/scenarios/qsccp1.py new file mode 100644 index 0000000..6fe76e7 --- /dev/null +++ b/scenarios/qsccp1.py @@ -0,0 +1,168 @@ +import os +import time +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + +PREFIX = "/A" + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info(f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n") + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + "qsccp1.conf", + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO") + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + addRoute(ndn, "c3", "r1", "/C") + addRoute(ndn, "c4", "r1", "/D") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + addRoute(ndn, "r1", "r2", "/C") + addRoute(ndn, "r1", "r2", "/D") + + addRoute(ndn, "r2", "r3", "/A") + addRoute(ndn, "r2", "r3", "/B") + addRoute(ndn, "r2", "r3", "/C") + addRoute(ndn, "r2", "r3", "/D") + + addRoute(ndn, "r3", "r4", "/A") + addRoute(ndn, "r3", "r4", "/B") + addRoute(ndn, "r3", "r4", "/C") + addRoute(ndn, "r3", "r4", "/D") + + addRoute(ndn, "r4", "p1", "/A") + addRoute(ndn, "r4", "p2", "/B") + addRoute(ndn, "r4", "p3", "/C") + addRoute(ndn, "r4", "p4", "/D") + + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p3/qsccp-server.log", "w") + getPopen( + ndn.net["p3"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p4/qsccp-server.log", "w") + getPopen( + ndn.net["p4"], + "cc-producer --prefix {}".format("/D"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + total_time = 120000 + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"qsccp-client --prefix /A --timingStop {total_time} --fixedRate 1000000 --tos 2", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c2"], + f"qsccp-client --prefix /B --timingStop {total_time} --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c3/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c3"], + f"qsccp-client --prefix /C --timingStop {total_time} --tos 6 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c4/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c4"], + f"qsccp-client --prefix /D/1 --timingStop {total_time} --tos 7 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + # printOutput(ping1.stdout.read()) + + # interface = ndn.net["b"].connectionsTo(ndn.net["a"])[0][0] + # info("Failing link\n") # failing link by setting link loss to 100% + # interface.config(delay="10ms", bw=10, loss=100) + # info ("\n starting ping2 client \n") + + # ping2 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) + # ping2.wait() + # printOutput(ping2.stdout.read()) + + # interface.config(delay="10ms", bw=10, loss=0) # bringing back the link + + info("\nExperiment Completed!\n") + MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() diff --git a/scenarios/qsccp2.py b/scenarios/qsccp2.py new file mode 100644 index 0000000..511dc8c --- /dev/null +++ b/scenarios/qsccp2.py @@ -0,0 +1,166 @@ +import os +import time +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info(f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n") + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + "qsccp2.conf", + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO") + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + addRoute(ndn, "c3", "r1", "/C") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + addRoute(ndn, "r1", "r2", "/C") + + addRoute(ndn, "r1", "r3", "/A") + addRoute(ndn, "r1", "r3", "/B") + addRoute(ndn, "r1", "r3", "/C") + + addRoute(ndn, "r2", "p1", "/A") + addRoute(ndn, "r2", "p1", "/B") + addRoute(ndn, "r2", "p1", "/C") + addRoute(ndn, "r3", "p2", "/A") + addRoute(ndn, "r3", "p3", "/B") + addRoute(ndn, "r3", "p4", "/C") + + + Nfdc.setStrategy(ndn.net["r1"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r1"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r1"], "/C", "QSCCP/%FD%01") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p3/qsccp-server.log", "w") + getPopen( + ndn.net["p3"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p4/qsccp-server.log", "w") + getPopen( + ndn.net["p4"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"qsccp-client --prefix /A --timingStop 90000 --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c2"], + f"qsccp-client --prefix /B --timingStop 120000 --delayStart 30000 --tos 6 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c3/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c3"], + f"qsccp-client --prefix /C --timingStop 150000 --delayStart 60000 --tos 7 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + # printOutput(ping1.stdout.read()) + + # interface = ndn.net["b"].connectionsTo(ndn.net["a"])[0][0] + # info("Failing link\n") # failing link by setting link loss to 100% + # interface.config(delay="10ms", bw=10, loss=100) + # info ("\n starting ping2 client \n") + + # ping2 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) + # ping2.wait() + # printOutput(ping2.stdout.read()) + + # interface.config(delay="10ms", bw=10, loss=0) # bringing back the link + + info("\nExperiment Completed!\n") + MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() diff --git a/scenarios/qsccp3.1.py b/scenarios/qsccp3.1.py new file mode 100644 index 0000000..0b70b05 --- /dev/null +++ b/scenarios/qsccp3.1.py @@ -0,0 +1,213 @@ +import os +import time +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info( + f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n" + ) + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + "qsccp3.1.conf", + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO") + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + addRoute(ndn, "c3", "r1", "/C") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + addRoute(ndn, "r1", "r2", "/C") + + addRoute(ndn, "r2", "r3", "/A") + addRoute(ndn, "r2", "r3", "/B") + addRoute(ndn, "r2", "r3", "/C") + + addRoute(ndn, "r2", "r4", "/A") + addRoute(ndn, "r2", "r4", "/B") + addRoute(ndn, "r2", "r4", "/C") + + addRoute(ndn, "r2", "r5", "/A") + addRoute(ndn, "r2", "r5", "/B") + addRoute(ndn, "r2", "r5", "/C") + + addRoute(ndn, "r4", "r3", "/A") + addRoute(ndn, "r4", "r3", "/B") + addRoute(ndn, "r4", "r3", "/C") + + addRoute(ndn, "r4", "r5", "/A") + addRoute(ndn, "r4", "r5", "/B") + addRoute(ndn, "r4", "r5", "/C") + + addRoute(ndn, "r3", "r6", "/A") + addRoute(ndn, "r3", "r6", "/B") + addRoute(ndn, "r3", "r6", "/C") + + addRoute(ndn, "r5", "r6", "/A") + addRoute(ndn, "r5", "r6", "/B") + addRoute(ndn, "r5", "r6", "/C") + + addRoute(ndn, "r6", "p1", "/A") + addRoute(ndn, "r6", "p1", "/B") + addRoute(ndn, "r6", "p1", "/C") + addRoute(ndn, "r6", "p2", "/A") + addRoute(ndn, "r6", "p3", "/B") + addRoute(ndn, "r6", "p4", "/C") + + Nfdc.setStrategy(ndn.net["r1"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r1"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r1"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r2"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r2"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r2"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r3"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r3"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r3"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r4"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r4"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r4"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r5"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r5"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r5"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r6"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r6"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r6"], "/C", "QSCCP/%FD%01") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p3/qsccp-server.log", "w") + getPopen( + ndn.net["p3"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p4/qsccp-server.log", "w") + getPopen( + ndn.net["p4"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"qsccp-client --prefix /A --timingStop 320000 --tos 5", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + getPopen( + ndn.net["c2"], + f"qsccp-client --prefix /B --timingStop 320000 --delayStart 80000 --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c3/qsccp-client.log", "w") + getPopen( + ndn.net["c3"], + f"qsccp-client --prefix /C --timingStop 320000 --delayStart 160000 --delayGreedy 240000 --greedyRate 10000000 --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + # printOutput(ping1.stdout.read()) + + # interface = ndn.net["b"].connectionsTo(ndn.net["a"])[0][0] + # info("Failing link\n") # failing link by setting link loss to 100% + # interface.config(delay="10ms", bw=10, loss=100) + # info ("\n starting ping2 client \n") + + # ping2 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) + # ping2.wait() + # printOutput(ping2.stdout.read()) + + # interface.config(delay="10ms", bw=10, loss=0) # bringing back the link + + info("\nExperiment Completed!\n") + MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() + diff --git a/scenarios/qsccp3.2.py b/scenarios/qsccp3.2.py new file mode 100644 index 0000000..1a7845e --- /dev/null +++ b/scenarios/qsccp3.2.py @@ -0,0 +1,212 @@ +import os +import time +from subprocess import PIPE + +from mininet.log import setLogLevel, info +from mininet.topo import Topo +from mininet.link import TCLink + +from minindn.minindn import Minindn +from minindn.apps.app_manager import AppManager +from minindn.util import MiniNDNCLI, getPopen +from minindn.apps.nfd import Nfd +from minindn.helpers.nfdc import Nfdc + + +def printOutput(output): + _out = output.decode("utf-8").split("\n") + for _line in _out: + info(_line + "\n") + + +def addRoute(ndn, node1: str, node2: str, prefix: str): + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + info( + f"Setting up route from {node1} to {node2} with interface {interface.IP()} => {prefix}\n" + ) + Nfdc.registerRoute(host1, prefix, interface.IP(), cost=0) + + +def run(): + Minindn.cleanUp() + Minindn.verifyDependencies() + + ndn = Minindn( + topoFile=os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + "topologies", + "qsccp3.2.conf", + ) + ) + ndn.start() + + # configure and start nfd on each node + info("Configuring NFD\n") + AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO") + + for link in ndn.topo.links(withInfo=True): + node1, node2, node_info = link + host1 = ndn.net[node1] + host2 = ndn.net[node2] + interface = host2.connectionsTo(host1)[0][0] + interface_ip = interface.IP() + bandwidth = interface.params.get("bw", 100) * 1000000 + info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n") + Nfdc.createFace(host1, interface_ip, bandwidth=bandwidth) + + addRoute(ndn, "c1", "r1", "/A") + addRoute(ndn, "c2", "r1", "/B") + addRoute(ndn, "c3", "r1", "/C") + + addRoute(ndn, "r1", "r2", "/A") + addRoute(ndn, "r1", "r2", "/B") + addRoute(ndn, "r1", "r2", "/C") + + addRoute(ndn, "r2", "r3", "/A") + addRoute(ndn, "r2", "r3", "/B") + addRoute(ndn, "r2", "r3", "/C") + + addRoute(ndn, "r2", "r4", "/A") + addRoute(ndn, "r2", "r4", "/B") + addRoute(ndn, "r2", "r4", "/C") + + addRoute(ndn, "r2", "r5", "/A") + addRoute(ndn, "r2", "r5", "/B") + addRoute(ndn, "r2", "r5", "/C") + + addRoute(ndn, "r4", "r3", "/A") + addRoute(ndn, "r4", "r3", "/B") + addRoute(ndn, "r4", "r3", "/C") + + addRoute(ndn, "r4", "r5", "/A") + addRoute(ndn, "r4", "r5", "/B") + addRoute(ndn, "r4", "r5", "/C") + + addRoute(ndn, "r3", "r6", "/A") + addRoute(ndn, "r3", "r6", "/B") + addRoute(ndn, "r3", "r6", "/C") + + addRoute(ndn, "r5", "r6", "/A") + addRoute(ndn, "r5", "r6", "/B") + addRoute(ndn, "r5", "r6", "/C") + + addRoute(ndn, "r6", "p1", "/A") + addRoute(ndn, "r6", "p1", "/B") + addRoute(ndn, "r6", "p1", "/C") + addRoute(ndn, "r6", "p2", "/A") + addRoute(ndn, "r6", "p3", "/B") + addRoute(ndn, "r6", "p4", "/C") + + Nfdc.setStrategy(ndn.net["r1"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r1"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r1"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r2"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r2"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r2"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r3"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r3"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r3"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r4"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r4"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r4"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r5"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r5"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r5"], "/C", "QSCCP/%FD%01") + + Nfdc.setStrategy(ndn.net["r6"], "/A", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r6"], "/B", "QSCCP/%FD%01") + Nfdc.setStrategy(ndn.net["r6"], "/C", "QSCCP/%FD%01") + + # Start cc server + info("Starting cc...\n") + qsccp_server_log = open(f"{ndn.workDir}/p1/qsccp-server.log", "w") + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + getPopen( + ndn.net["p1"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p2/qsccp-server.log", "w") + getPopen( + ndn.net["p2"], + "cc-producer --prefix {}".format("/A"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p3/qsccp-server.log", "w") + getPopen( + ndn.net["p3"], + "cc-producer --prefix {}".format("/B"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + qsccp_server_log = open(f"{ndn.workDir}/p4/qsccp-server.log", "w") + getPopen( + ndn.net["p4"], + "cc-producer --prefix {}".format("/C"), + stdout=qsccp_server_log, + stderr=qsccp_server_log, + ) + + # start cc client + qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w") + ping1 = getPopen( + ndn.net["c1"], + f"qsccp-client --prefix /A --timingStop 320000 --tos 5", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w") + getPopen( + ndn.net["c2"], + f"qsccp-client --prefix /B --timingStop 320000 --delayStart 80000 --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + qsccp_client_log = open(f"{ndn.workDir}/c3/qsccp-client.log", "w") + getPopen( + ndn.net["c3"], + f"qsccp-client --prefix /C --timingStop 320000 --delayStart 160000 --delayGreedy 240000 --greedyRate 10000000 --tos 5 --initialSendRate 50000", + stdout=qsccp_client_log, + stderr=qsccp_client_log, + ) + ping1.wait() + # printOutput(ping1.stdout.read()) + + # interface = ndn.net["b"].connectionsTo(ndn.net["a"])[0][0] + # info("Failing link\n") # failing link by setting link loss to 100% + # interface.config(delay="10ms", bw=10, loss=100) + # info ("\n starting ping2 client \n") + + # ping2 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) + # ping2.wait() + # printOutput(ping2.stdout.read()) + + # interface.config(delay="10ms", bw=10, loss=0) # bringing back the link + + info("\nExperiment Completed!\n") + MiniNDNCLI(ndn.net) + ndn.stop() + + +if __name__ == "__main__": + setLogLevel("info") + run() diff --git a/topologies/qsccp1.conf b/topologies/qsccp1.conf new file mode 100644 index 0000000..c9dd07f --- /dev/null +++ b/topologies/qsccp1.conf @@ -0,0 +1,26 @@ +[nodes] +C1: _ +C2: _ +C3: _ +C4: _ +R1: _ +R2: _ +R3: _ +R4: _ +P1: _ +P2: _ +P3: _ +P4: _ + +[links] +C1:R1 delay=10ms bw=100 +C2:R1 delay=10ms bw=100 +C3:R1 delay=10ms bw=100 +C4:R1 delay=10ms bw=100 +R1:R2 delay=10ms bw=100 +R2:R3 delay=10ms bw=10 +R3:R4 delay=10ms bw=100 +R4:P1 delay=10ms bw=100 +R4:P2 delay=10ms bw=100 +R4:P3 delay=10ms bw=100 +R4:P4 delay=10ms bw=100 diff --git a/topologies/qsccp2.conf b/topologies/qsccp2.conf new file mode 100644 index 0000000..ec86ac1 --- /dev/null +++ b/topologies/qsccp2.conf @@ -0,0 +1,22 @@ +[nodes] +C1: _ +C2: _ +C3: _ +R1: _ +R2: _ +R3: _ +P1: _ +P2: _ +P3: _ +P4: _ + +[links] +C1:R1 delay=10ms bw=100 +C2:R1 delay=10ms bw=100 +C3:R1 delay=10ms bw=100 +R1:R2 delay=10ms bw=5 +R1:R3 delay=10ms bw=5 +R2:P1 delay=10ms bw=100 +R3:P2 delay=10ms bw=100 +R3:P3 delay=10ms bw=100 +R3:P4 delay=10ms bw=100 diff --git a/topologies/qsccp3.1.conf b/topologies/qsccp3.1.conf new file mode 100644 index 0000000..51ac0b7 --- /dev/null +++ b/topologies/qsccp3.1.conf @@ -0,0 +1,31 @@ +[nodes] +C1: _ +C2: _ +C3: _ +R1: _ +R2: _ +R3: _ +R4: _ +R5: _ +R6: _ +P1: _ +P2: _ +P3: _ +P4: _ + +[links] +C1:R1 delay=10ms bw=100 +C2:R1 delay=10ms bw=100 +C3:R1 delay=10ms bw=100 +R1:R2 delay=10ms bw=100 +R2:R3 delay=10ms bw=1 +R2:R4 delay=5ms bw=8 +R2:R5 delay=10ms bw=5 +R4:R3 delay=5ms bw=6 +R4:R5 delay=5ms bw=2 +R3:R6 delay=10ms bw=7 +R5:R6 delay=10ms bw=7 +R6:P1 delay=10ms bw=100 +R6:P2 delay=10ms bw=100 +R6:P3 delay=10ms bw=100 +R6:P4 delay=10ms bw=100 \ No newline at end of file diff --git a/topologies/qsccp3.2.conf b/topologies/qsccp3.2.conf new file mode 100644 index 0000000..476645c --- /dev/null +++ b/topologies/qsccp3.2.conf @@ -0,0 +1,31 @@ +[nodes] +C1: _ +C2: _ +C3: _ +R1: _ +R2: _ +R3: _ +R4: _ +R5: _ +R6: _ +P1: _ +P2: _ +P3: _ +P4: _ + +[links] +C1:R1 delay=10ms bw=100 +C2:R1 delay=10ms bw=100 +C3:R1 delay=10ms bw=100 +R1:R2 delay=10ms bw=100 +R2:R3 delay=10ms bw=3.5 +R2:R4 delay=10ms bw=7 +R2:R5 delay=20ms bw=3.5 +R4:R3 delay=5ms bw=3.5 +R4:R5 delay=5ms bw=3.5 +R3:R6 delay=5ms bw=7 +R5:R6 delay=10ms bw=7 +R6:P1 delay=10ms bw=100 +R6:P2 delay=10ms bw=100 +R6:P3 delay=10ms bw=100 +R6:P4 delay=10ms bw=100 \ No newline at end of file diff --git a/util/pkgdep/common.sh b/util/pkgdep/common.sh index 60749ef..2199a4f 100644 --- a/util/pkgdep/common.sh +++ b/util/pkgdep/common.sh @@ -36,6 +36,7 @@ DEP_INFO=( ["CXX"]="ndn-cxx,ndn-cxx,libndn-cxx-dev,https://github.com/named-data/ndn-cxx.git,ndn-cxx" ["NFD"]="NFD,NFD,nfd,https://github.com/named-data/NFD.git,NFD" ["PSYNC"]="PSync,PSync,libpsync-dev,https://github.com/named-data/PSync.git,PSync" + ["CHRONOSYNC"]="ChronoSync,ChronoSync,ChronoSync,https://github.com/named-data/ChronoSync.git" ["NLSR"]="NLSR,NLSR,nlsr,https://github.com/named-data/NLSR.git,NLSR" ["TOOLS"]="ndn-tools,NDN Essential Tools,ndn-tools,https://github.com/named-data/ndn-tools.git,ndn-tools" ["TRAFFIC"]="ndn-traffic-generator,NDN Traffic Generator,ndn-traffic-generator,https://github.com/named-data/ndn-traffic-generator.git,ndn-traffic-generator" @@ -233,7 +234,7 @@ if [[ $PPA_AVAIL -ne 1 ]] || [[ $NO_PPA -eq 1 ]]; then fi # dep install order, excluding ndn-cxx -DEPLIST=(NFD PSYNC NLSR TOOLS TRAFFIC INFOEDIT MININET) +DEPLIST=(NFD PSYNC CHRONOSYNC NLSR TOOLS TRAFFIC INFOEDIT MININET) if [[ $NO_WIFI -ne 1 ]]; then DEPLIST+=(MNWIFI) fi