feat(cc): Add pcon,bbr scenario

.gitignore

@@ -19,3 +19,4 @@ dl
 
 venv/
 .vscode
+compare_data*

compare_test.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+function do_compare() {
+    scenario=$1
+    echo "Running $scenario"
+    for i in {1..10}
+    do
+        echo "Running $scenario $i"
+        mkdir -p /mini-ndn/compare_data/${scenario}_50ms
+        python scenarios/$scenario.py compare_50ms.conf
+        mv /tmp/minindn /mini-ndn/compare_data/${scenario}_50ms/${i}
+        mkdir -p /mini-ndn/compare_data/${scenario}_100ms
+        python scenarios/$scenario.py compare_100ms.conf
+        mv /tmp/minindn /mini-ndn/compare_data/${scenario}_100ms/${i}
+        mkdir -p /mini-ndn/compare_data/${scenario}_150ms
+        python scenarios/$scenario.py compare_150ms.conf
+        mv /tmp/minindn /mini-ndn/compare_data/${scenario}_150ms/${i}
+        mkdir -p /mini-ndn/compare_data/${scenario}_200ms
+        python scenarios/$scenario.py compare_200ms.conf
+        mv /tmp/minindn /mini-ndn/compare_data/${scenario}_200ms/${i}
+        mkdir -p /mini-ndn/compare_data/${scenario}_250ms
+        python scenarios/$scenario.py compare_250ms.conf
+        mv /tmp/minindn /mini-ndn/compare_data/${scenario}_250ms/${i}
+    done
+    echo "Finished $scenario"
+}
+
+do_compare "cubic_reno"
+do_compare "cubic_cubic"
+do_compare "cubic_bic"
+do_compare "cubic_bbr"
+# do_compare "cubic_qsccp"

compress.sh

@@ -0,0 +1,18 @@
+function do_compress() {
+    scenario=$1
+    for i in {1..10}
+    do
+        for ms in 50 100 150 200 250
+        do
+            ls ${scenario}_${ms}ms/${i}
+            find ${scenario}_${ms}ms/${i} -mindepth 1 -maxdepth 1 -not \( -name 'c1' -or -name 'c2' \) -exec rm -rf {} \;
+            # 遍历 ${scenario}_${ms}ms/1-10 目录，删除里面所有不为 c1 或者 c2 的文件和目录
+            # find ${scenario}_${ms}ms/${i} -maxdepth 1 -not \( -name 'c1' -or -name 'c2' \) -exec rm -rf {} \;
+        done
+    done
+}
+
+do_compress "compare_data/cubic_qsccp"
+do_compress "compare_data/cubic_reno"
+do_compress "compare_data/cubic_bic"
+do_compress "compare_data/cubic_cubic"

minindn/apps/nfd.py

@@ -27,7 +27,7 @@ from minindn.minindn import Minindn
 
 class Nfd(Application):
 
-    def __init__(self, node, logLevel='NONE', csSize=65536,
+    def __init__(self, node, logLevel='NONE', csSize=0,
                  csPolicy='lru', csUnsolicitedPolicy='drop-all'):
         Application.__init__(self, node)
 

minindn/helpers/nfdc.py

@@ -76,12 +76,12 @@ class Nfdc(object):
         Minindn.sleep(SLEEP_TIME)
 
     @staticmethod
-    def createFace(node, remoteNodeAddress, protocol='udp', isPermanent=False, allowExisting=True, bandwidth=100000000):
+    def createFace(node, remoteNodeAddress, protocol=PROTOCOL_UDP, isPermanent=False, allowExisting=True, bandwidth=-1):
         '''Create face in node's NFD instance. Returns FaceID of created face or -1 if failed.'''
-        cmd = ('nfdc face create {}://{} bandwidth {} persistency {}'.format(
+        cmd = ('nfdc face create {}://{}{} persistency {}'.format(
             protocol,
             remoteNodeAddress,
-            int(bandwidth),
+            f" bandwidth {int(bandwidth)}" if bandwidth > 0 else "",
             'permanent' if isPermanent else 'persistent'
         ))
         output = node.cmd(cmd)
@@ -94,7 +94,7 @@ class Nfdc(object):
         return -1
 
     @staticmethod
-    def destroyFace(node, remoteNode, protocol='udp'):
+    def destroyFace(node, remoteNode, protocol=PROTOCOL_UDP):
         if remoteNode.isdigit() and not protocol == "fd":
             debug(node.cmd('nfdc face destroy {}'.format(protocol, remoteNode)))
         else:
@@ -115,7 +115,7 @@ class Nfdc(object):
         Minindn.sleep(SLEEP_TIME)
 
     @staticmethod
-    def getFaceId(node, remoteNodeAddress, localEndpoint=None, protocol="udp", portNum="6363"):
+    def getFaceId(node, remoteNodeAddress, localEndpoint=None, protocol=PROTOCOL_UDP, portNum="6363"):
         '''Returns the faceId for a remote node based on FaceURI, or -1 if a face is not found'''
         #Should this be cached or is the hit not worth it?
         local = ""

scenarios/bbr_test.py

@@ -0,0 +1,127 @@
+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",
+            "pcon_test.conf",
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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, "r1", "r2", "/A")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+
+    # 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,
+    )
+
+    total_time = 20000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c1/bbr-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"bbr-client --prefix /A --timingStop {total_time}",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c3/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c3"],
+    #     f"pcon-client --prefix /C --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c4/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c4"],
+    #     f"pcon-client --prefix /D/1 --timingStop {total_time} --ccAlgorithm BIC",
+    #     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/compare.py

@@ -0,0 +1,160 @@
+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",
+            "compare.conf",
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+    addRoute(ndn, "r2", "p3", "/C")
+
+    # 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,
+    )
+
+    total_time = 240000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c1/pcon-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm BIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c2"],
+        f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm CUBIC",
+        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 5 --initialSendRate 50000",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c3/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c3"],
+    #     f"pcon-client --prefix /C --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c4/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c4"],
+    #     f"pcon-client --prefix /D/1 --timingStop {total_time} --ccAlgorithm BIC",
+    #     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/cubic_bbr.py

@@ -0,0 +1,110 @@
+import os
+import time
+import sys
+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",
+            sys.argv[1],
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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)
+    
+    addRoute(ndn, "c1", "r1", "/A")
+    addRoute(ndn, "c2", "r1", "/B")
+    
+    addRoute(ndn, "r1", "r2", "/A")
+    addRoute(ndn, "r1", "r2", "/B")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+
+    # 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,
+    )
+    
+    total_time = 120000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c2"],
+        f"bbr-client --prefix /B --timingStop {total_time}",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm CUBIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    ping1.wait()
+
+    info("\nExperiment Completed!\n")
+    # MiniNDNCLI(ndn.net)
+    ndn.stop()
+
+
+if __name__ == "__main__":
+    setLogLevel("info")
+    run()

scenarios/cubic_bic.py

@@ -0,0 +1,110 @@
+import os
+import time
+import sys
+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",
+            sys.argv[1],
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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)
+    
+    addRoute(ndn, "c1", "r1", "/A")
+    addRoute(ndn, "c2", "r1", "/B")
+    
+    addRoute(ndn, "r1", "r2", "/A")
+    addRoute(ndn, "r1", "r2", "/B")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+
+    # 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,
+    )
+    
+    total_time = 120000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c2"],
+        f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm CUBIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    ping1.wait()
+
+    info("\nExperiment Completed!\n")
+    # MiniNDNCLI(ndn.net)
+    ndn.stop()
+
+
+if __name__ == "__main__":
+    setLogLevel("info")
+    run()

scenarios/cubic_cubic.py

@@ -0,0 +1,109 @@
+import os
+import sys
+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",
+            sys.argv[1],
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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)
+    
+    addRoute(ndn, "c1", "r1", "/A")
+    addRoute(ndn, "c2", "r1", "/B")
+    
+    addRoute(ndn, "r1", "r2", "/A")
+    addRoute(ndn, "r1", "r2", "/B")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+
+    # 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,
+    )
+    
+    total_time = 120000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c2"],
+        f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm CUBIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm CUBIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    ping1.wait()
+
+    info("\nExperiment Completed!\n")
+    # MiniNDNCLI(ndn.net)
+    ndn.stop()
+
+
+if __name__ == "__main__":
+    setLogLevel("info")
+    run()

scenarios/cubic_qsccp.py

@@ -0,0 +1,109 @@
+import os
+import sys
+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",
+            sys.argv[1],
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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, "r1", "r2", "/A")
+    addRoute(ndn, "r1", "r2", "/B")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+
+    # 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,
+    )
+    
+    total_time = 120000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm CUBIC",
+        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,
+    )
+    ping1.wait()
+
+    info("\nExperiment Completed!\n")
+    # MiniNDNCLI(ndn.net)
+    ndn.stop()
+
+
+if __name__ == "__main__":
+    setLogLevel("info")
+    run()

scenarios/cubic_reno.py

@@ -0,0 +1,109 @@
+import os
+import sys
+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",
+            sys.argv[1],
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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)
+    
+    addRoute(ndn, "c1", "r1", "/A")
+    addRoute(ndn, "c2", "r1", "/B")
+    
+    addRoute(ndn, "r1", "r2", "/A")
+    addRoute(ndn, "r1", "r2", "/B")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+
+    # 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,
+    )
+    
+    total_time = 120000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c2/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c2"],
+        f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm AIMD",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    
+    qsccp_client_log = open(f"{ndn.workDir}/c1/qsccp-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm CUBIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    ping1.wait()
+
+    info("\nExperiment Completed!\n")
+    ndn.stop()
+
+
+if __name__ == "__main__":
+    setLogLevel("info")
+    run()

scenarios/pcon1.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)
+    
+    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/pcon-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm BIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c3/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c3"],
+    #     f"pcon-client --prefix /C --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c4/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c4"],
+    #     f"pcon-client --prefix /D/1 --timingStop {total_time} --ccAlgorithm BIC",
+    #     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/pcon3.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)
+
+    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", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r1"], "/B", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r1"], "/C", "PCON/%FD%01")
+    
+    Nfdc.setStrategy(ndn.net["r2"], "/A", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r2"], "/B", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r2"], "/C", "PCON/%FD%01")
+    
+    Nfdc.setStrategy(ndn.net["r3"], "/A", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r3"], "/B", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r3"], "/C", "PCON/%FD%01")
+    
+    Nfdc.setStrategy(ndn.net["r4"], "/A", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r4"], "/B", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r4"], "/C", "PCON/%FD%01")
+    
+    Nfdc.setStrategy(ndn.net["r5"], "/A", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r5"], "/B", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r5"], "/C", "PCON/%FD%01")
+    
+    Nfdc.setStrategy(ndn.net["r6"], "/A", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r6"], "/B", "PCON/%FD%01")
+    Nfdc.setStrategy(ndn.net["r6"], "/C", "PCON/%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/pcon-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop 320000",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop 320000 --delayStart 20000 --initialWindowSize 20",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c3/pcon-client.log", "w")
+    # getPopen(
+    #     ndn.net["c3"],
+    #     f"pcon-client --prefix /C --timingStop 320000 --delayStart 160000 --delayGreedy 240000 --greedyRate 10000000 --initialWindowSize 20",
+    #     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/pcon_test.py

@@ -0,0 +1,127 @@
+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",
+            "pcon_test.conf",
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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, "r1", "r2", "/A")
+    
+    addRoute(ndn, "r2", "p1", "/A")
+
+    # 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,
+    )
+
+    total_time = 40000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c1/pcon-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm CUBIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c3/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c3"],
+    #     f"pcon-client --prefix /C --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c4/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c4"],
+    #     f"pcon-client --prefix /D/1 --timingStop {total_time} --ccAlgorithm BIC",
+    #     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/qsccp_bic.py

@@ -0,0 +1,160 @@
+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",
+            "compare.conf",
+        )
+    )
+    ndn.start()
+
+    # configure and start nfd on each node
+    info("Configuring NFD\n")
+    AppManager(ndn, ndn.net.hosts, Nfd, logLevel="INFO", csSize=0)
+
+    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", "p1", "/A")
+    addRoute(ndn, "r2", "p2", "/B")
+    addRoute(ndn, "r2", "p3", "/C")
+
+    # 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,
+    )
+
+    total_time = 240000
+
+    # start cc client
+    qsccp_client_log = open(f"{ndn.workDir}/c1/pcon-client.log", "w")
+    ping1 = getPopen(
+        ndn.net["c1"],
+        f"pcon-client --prefix /A --timingStop {total_time} --ccAlgorithm BIC",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm CUBIC",
+    #     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 5 --initialSendRate 50000",
+        stdout=qsccp_client_log,
+        stderr=qsccp_client_log,
+    )
+    # qsccp_client_log = open(f"{ndn.workDir}/c2/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c2"],
+    #     f"pcon-client --prefix /B --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c3/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c3"],
+    #     f"pcon-client --prefix /C --timingStop {total_time} --ccAlgorithm BIC",
+    #     stdout=qsccp_client_log,
+    #     stderr=qsccp_client_log,
+    # )
+    # qsccp_client_log = open(f"{ndn.workDir}/c4/pcon-client.log", "w")
+    # ping1 = getPopen(
+    #     ndn.net["c4"],
+    #     f"pcon-client --prefix /D/1 --timingStop {total_time} --ccAlgorithm BIC",
+    #     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/compare.conf

@@ -0,0 +1,19 @@
+[nodes]
+C1: _
+C2: _
+C3: _
+R1: _
+R2: _
+P1: _
+P2: _
+P3: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+C3:R1 delay=10ms bw=100
+R1:R2 delay=10ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+R2:P3 delay=10ms bw=100
+

topologies/compare_100ms.conf

@@ -0,0 +1,15 @@
+[nodes]
+C1: _
+C2: _
+R1: _
+R2: _
+P1: _
+P2: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+R1:R2 delay=80ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+

topologies/compare_150ms.conf

@@ -0,0 +1,15 @@
+[nodes]
+C1: _
+C2: _
+R1: _
+R2: _
+P1: _
+P2: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+R1:R2 delay=130ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+

topologies/compare_200ms.conf

@@ -0,0 +1,15 @@
+[nodes]
+C1: _
+C2: _
+R1: _
+R2: _
+P1: _
+P2: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+R1:R2 delay=180ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+

topologies/compare_250ms.conf

@@ -0,0 +1,15 @@
+[nodes]
+C1: _
+C2: _
+R1: _
+R2: _
+P1: _
+P2: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+R1:R2 delay=230ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+

topologies/compare_50ms.conf

@@ -0,0 +1,15 @@
+[nodes]
+C1: _
+C2: _
+R1: _
+R2: _
+P1: _
+P2: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+R1:R2 delay=30ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+

topologies/compare_two.conf

@@ -0,0 +1,15 @@
+[nodes]
+C1: _
+C2: _
+R1: _
+R2: _
+P1: _
+P2: _
+
+[links]
+C1:R1 delay=10ms bw=100
+C2:R1 delay=10ms bw=100
+R1:R2 delay=10ms bw=10
+R2:P1 delay=10ms bw=100
+R2:P2 delay=10ms bw=100
+

topologies/pcon_test.conf

@@ -0,0 +1,10 @@
+[nodes]
+C1: _
+R1: _
+R2: _
+P1: _
+
+[links]
+C1:R1 delay=10ms bw=100
+R1:R2 delay=10ms bw=10
+R2:P1 delay=10ms bw=100