# -*- 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/>.

import argparse

import sys

import time

import os

import configparser

from subprocess import call, Popen, PIPE

import shutil

import glob

from traceback import format_exc

from mininet.topo import Topo

from mininet.net import Mininet

from mininet.link import TCLink

from mininet.node import Switch

from mininet.util import ipStr, ipParse

from mininet.log import info, debug, error

class Minindn(object):

"""

This class provides the following features to the user:

1) Wrapper around Mininet object with option to pass topology directly

1.1) Users can pass custom argument parser to extend the default on here

2) Parses the topology file given via command line if user does not pass a topology object

3) Provides way to stop Mini-NDN via stop

3.1) Applications register their clean up function with this class

4) Sets IPs on neighbors for connectivity required in a switch-less topology

5) Some other utility functions

"""

ndnSecurityDisabled = False

workDir = '/tmp/minindn'

resultDir = None

def __init__(self, parser=argparse.ArgumentParser(), topo=None, topoFile=None, noTopo=False,

link=TCLink, workDir=None, **mininetParams):

"""

Create MiniNDN object

:param parser: Parent parser of Mini-NDN parser

:param topo: Mininet topo object (optional)

:param topoFile: Mininet topology file location (optional)

:param noTopo: Allows specification of topology after network object is

initialized (optional)

:param link: Allows specification of default Mininet link type for connections between

nodes (optional)

:param mininetParams: Any params to pass to Mininet

"""

self.parser = Minindn.parseArgs(parser)

self.args = self.parser.parse_args()

if not workDir:

Minindn.workDir = os.path.abspath(self.args.workDir)

else:

Minindn.workDir = os.path.abspath(workDir)

Minindn.resultDir = self.args.resultDir

if not topoFile:

# Args has default topology if none specified

self.topoFile = self.args.topoFile

else:

self.topoFile = topoFile

self.faces_to_create = {}

if topo is None and not noTopo:

try:

info('Using topology file {}\n'.format(self.topoFile))

self.topo, self.faces_to_create = self.processTopo(self.topoFile)

except configparser.NoSectionError as e:

info('Error reading config file: {}\n'.format(e))

sys.exit(1)

else:

self.topo = topo

if not noTopo:

self.net = Mininet(topo=self.topo, link=link, **mininetParams)

else:

self.net = Mininet(link=link, **mininetParams)

self.initParams(self.net.hosts)

self.cleanups = []

if not self.net.switches:

self.ethernetPairConnectivity()

try:

process = Popen(['ndnsec-get-default', '-k'], stdout=PIPE, stderr=PIPE)

output, error = process.communicate()

if process.returncode == 0:

Minindn.ndnSecurityDisabled = '/dummy/KEY/-%9C%28r%B8%AA%3B%60' in output.decode("utf-8")

info('Dummy key chain patch is installed in ndn-cxx. Security will be disabled.\n')

else:

debug(error)

except:

pass

@staticmethod

def parseArgs(parent):

parser = argparse.ArgumentParser(prog='minindn', parents=[parent], add_help=False)

# nargs='?' required here since optional argument

parser.add_argument('topoFile', nargs='?', default='/usr/local/etc/mini-ndn/default-topology.conf',

help='If no template_file is given, topologies/default-topology.conf \

will be used.')

parser.add_argument('--work-dir', action='store', dest='workDir', default='/tmp/minindn',

help='Specify the working directory; default is /tmp/minindn')

parser.add_argument('--result-dir', action='store', dest='resultDir', default=None,

help='Specify the full path destination folder where experiment \

results will be moved')

return parser

def ethernetPairConnectivity(self):

ndnNetBase = '10.0.0.0'

interfaces = []

for host in self.net.hosts:

for intf in host.intfList():

link = intf.link

node1, node2 = link.intf1.node, link.intf2.node

if isinstance(node1, Switch) or isinstance(node2, Switch):

continue

if link.intf1 not in interfaces and link.intf2 not in interfaces:

interfaces.append(link.intf1)

interfaces.append(link.intf2)

node1.setIP(ipStr(ipParse(ndnNetBase) + 1) + '/30', intf=link.intf1)

node2.setIP(ipStr(ipParse(ndnNetBase) + 2) + '/30', intf=link.intf2)

ndnNetBase = ipStr(ipParse(ndnNetBase) + 4)

@staticmethod

def processTopo(topoFile):

config = configparser.ConfigParser(delimiters=' ', allow_no_value=True)

config.read(topoFile)

topo = Topo()

items = config.items('nodes')

coordinates = []

for item in items:

name = item[0].split(':')[0]

params = {}

if item[1]:

if all (x in item[1] for x in ['radius', 'angle']) and item[1] in coordinates:

error("FATAL: Duplicate Coordinate, \'{}\' used by multiple nodes\n" \

.format(item[1]))

sys.exit(1)

coordinates.append(item[1])

for param in item[1].split(' '):

if param == '_':

continue

params[param.split('=')[0]] = param.split('=')[1]

topo.addHost(name, params=params)

try:

items = config.items('switches')

for item in items:

name = item[0].split(':')[0]

topo.addSwitch(name)

except configparser.NoSectionError:

# Switches are optional

pass

items = config.items('links')

for item in items:

link = item[0].split(':')

params = {}

for param in item[1].split(' '):

key = param.split('=')[0]

value = param.split('=')[1]

if key in ['jitter', 'max_queue_size']:

value = int(value)

if key == 'loss' or key == 'bw':

value = float(value)

params[key] = value

topo.addLink(link[0], link[1], **params)

faces = {}

try:

items = config.items('faces')

debug("Faces")

for item in items:

face_a, face_b = item[0].split(':')

debug(item)

cost = -1

for param in item[1].split(' '):

if param.split("=")[0] == 'cost':

cost = param.split("=")[1]

face_info = (face_b, int(cost))

if face_a not in faces:

faces[face_a] = [face_info]

else:

faces[face_a].append(face_info)

except configparser.NoSectionError:

debug("Faces section is optional")

pass

return (topo, faces)

return topo

def start(self):

self.net.start()

time.sleep(3)

def stop(self):

for cleanup in self.cleanups:

cleanup()

self.net.stop()

if Minindn.resultDir is not None:

info("Moving results to \'{}\'\n".format(Minindn.resultDir))

os.system("mkdir -p {}".format(Minindn.resultDir))

for file in glob.glob('{}/*'.format(Minindn.workDir)):

shutil.move(file, Minindn.resultDir)

@staticmethod

def cleanUp():

devnull = open(os.devnull, 'w')

call('nfd-stop', stdout=devnull, stderr=devnull)

call('mn --clean'.split(), stdout=devnull, stderr=devnull)

@staticmethod

def verifyDependencies():

"""Prevent MiniNDN from running without necessary dependencies"""

dependencies = ['nfd', 'nlsr', 'infoedit', 'ndnping', 'ndnpingserver']

devnull = open(os.devnull, 'w')

# Checks that each program is in the system path

for program in dependencies:

if call(['which', program], stdout=devnull):

error('{} is missing from the system path! Exiting...\n'.format(program))

sys.exit(1)

devnull.close()

@staticmethod

def sleep(seconds):

# sleep is not required if ndn-cxx is using in-memory keychain

if not Minindn.ndnSecurityDisabled:

time.sleep(seconds)

@staticmethod

def handleException():

"""Utility method to perform cleanup steps and exit after catching exception"""

Minindn.cleanUp()

info(format_exc())

exit(1)

def getInterfaceDelay(self, node, interface):

tc_output = node.cmd("tc qdisc show dev {}".format(interface))

for line in tc_output.splitlines():

if "qdisc netem 10:" in line:

split_line = line.split(" ")

for index in range(0, len(split_line)):

if split_line[index] == "delay":

return float(split_line[index + 1][:-2])

return 0.0

def initParams(self, nodes):

"""Initialize Mini-NDN parameters for array of nodes"""

for host in nodes:

if 'params' not in host.params:

host.params['params'] = {}

host.params['params']['workDir'] = Minindn.workDir

homeDir = '{}/{}'.format(Minindn.workDir, host.name)

host.params['params']['homeDir'] = homeDir

host.cmd('mkdir -p {}'.format(homeDir))

host.cmd('export HOME={} && cd ~'.format(homeDir))

def nfdcBatchProcessing(self, station, faces):

# Input format: [IP, protocol, isPermanent]

batch_file = open("{}/{}/nfdc.batch".format(Minindn.workDir, station.name), "w")

lines = []

for face in faces:

ip = face[0]

protocol = face[1]

if face[2]:

face_type = "permanent"

else:

face_type = "persistent"

nfdc_command = "face create {}://{} {}\n".format(protocol, ip, face_type)

lines.append(nfdc_command)

batch_file.writelines(lines)

batch_file.close()

debug(station.cmd("nfdc -f {}/{}/nfdc.batch".format(Minindn.workDir, station.name)))

def setupFaces(self, faces_to_create=None):

""" Method to create unicast faces between connected nodes;

Returns dict- {node: (other node name, other node IP, other node's delay as int)}.

This is intended to pass to the NLSR helper via the faceDict param """

if not faces_to_create:

faces_to_create = self.faces_to_create

# (nodeName, IP, delay as int)

# list of tuples

created_faces = dict()

batch_faces = dict()

for nodeAname in faces_to_create.keys():

if not nodeAname in batch_faces.keys():

batch_faces[nodeAname] = []

for nodeBname, faceCost in faces_to_create[nodeAname]:

if not nodeBname in batch_faces.keys():

batch_faces[nodeBname] = []

nodeA = self.net[nodeAname]

nodeB = self.net[nodeBname]

if nodeA.connectionsTo(nodeB):

best_interface = None

delay = None

for interface in nodeA.connectionsTo(nodeB):

interface_delay = self.getInterfaceDelay(nodeA, interface[0])

if not delay or int(interface_delay) < delay:

best_interface = interface

faceAIP = best_interface[0].IP()

faceBIP = best_interface[1].IP()

# Node delay will be symmetrical for connected nodes

nodeDelay = int(self.getInterfaceDelay(nodeA, best_interface[0]))

#nodeBDelay = int(self.getInterfaceDelay(nodeB, best_interface[1]))

else:

# If no direct wired connections exist (ie when using a switch),

# assume the default interface

faceAIP = nodeA.IP()

faceBIP = nodeB.IP()

nodeADelay = int(self.getInterfaceDelay(nodeA, nodeA.defaultIntf()))

nodeBDelay = int(self.getInterfaceDelay(nodeB, nodeB.defaultIntf()))

nodeDelay = nodeADelay + nodeBDelay

if not faceCost == -1:

nodeALink = (nodeA.name, faceAIP, faceCost)

nodeBLink = (nodeB.name, faceBIP, faceCost)

else:

nodeALink = (nodeA.name, faceAIP, nodeDelay)

nodeBLink = (nodeB.name, faceBIP, nodeDelay)

# Importing this before initialization causes issues

batch_faces[nodeAname].append([faceBIP, "udp", True])

batch_faces[nodeBname].append([faceAIP, "udp", True])

if nodeA not in created_faces:

created_faces[nodeA] = [nodeBLink]

else:

created_faces[nodeA].append(nodeBLink)

if nodeB not in created_faces:

created_faces[nodeB] = [nodeALink]

else:

created_faces[nodeB].append(nodeALink)

for station_name in batch_faces.keys():

self.nfdcBatchProcessing(self.net[station_name], batch_faces[station_name])

return created_faces