feat(qsccp): Add qsccp scenario

.gitignore

@@ -16,3 +16,6 @@ dl
 
 # Vagrant
 .vagrant
+
+venv/
+.vscode

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(a, b, delay='10ms', bw=2.5) # bw = bandwidth
-    topo.addLink(b, c, delay='10ms', bw=10)
+    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 link in topo.links(withInfo=True):
-    for first in links:
+        node1, node2, node_info = link
-        for second in links[first]:
+        host1 = ndn.net[node1]
-            host1 = ndn.net[first]
+        host2 = ndn.net[node2]
-            host2 = ndn.net[second]
+        interface = host2.connectionsTo(host1)[0][0]
-            interface = host2.connectionsTo(host1)[0][0]
+        interface_ip = interface.IP()
-            interface_ip = interface.IP()
+        bandwidth = interface.params.get("bw", 100) * 1000000
-            Nfdc.createFace(host1, interface_ip)
+        info(f"Setting up route from {node1} to {node2} with bandwidth {bandwidth}\n")
-            Nfdc.registerRoute(host1, PREFIX, interface_ip, cost=0)
+        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")

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 <http://www.gnu.org/licenses/>.
+
+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()

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)

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

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()

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()

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()
+

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()

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

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

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

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

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