def instantiateGraph(mininet):
MAX_X = mininetWiFi.MAX_X
MAX_Y = mininetWiFi.MAX_Y
nodes = mininet.stations + mininet.accessPoints
for node in nodes:
replayingMobility.addNode(node)
plot2d.instantiateGraph(MAX_X, MAX_Y)
plot2d.plotGraph(nodes, [], [])
def __init__(self, mininet, stdin=sys.stdin, script=None):
"""Start and run interactive or batch mode CLI
mininet: Mininet network object
stdin: standard input for CLI
script: script to run in batch mode"""
if mobility.isMobility == False and mobility.DRAW and mininet.alreadyPlotted == False:
mininet.checkAPAdhoc()
for sta in mininet.stations:
if 'position' not in sta.params:
sta.params['position'] = 0, 0, 0
if mobility.accessPoints == []:
mobility.accessPoints = mininet.accessPoints
if mobility.stations == []:
mobility.stations = mininet.stations
nodes = mininet.stations + mininet.accessPoints + mininet.plotNodes
try:
if mininet.is3d:
plot3d.instantiateGraph(mininet.MAX_X, mininet.MAX_Y,
mininet.MAX_Z)
plot3d.graphInstantiateNodes(nodes)
else:
plot2d.instantiateGraph(mininet.MAX_X, mininet.MAX_Y)
plot2d.plotGraph(nodes, mininet.srcConn, mininet.dstConn)
plot2d.graphPause()
except:
info(
'Warning: This OS does not support GUI. Running without GUI.\n'
)
mobility.DRAW = False
self.mn = mininet
# Local variable bindings for py command
self.locals = {'net': mininet}
# Attempt to handle input
self.stdin = stdin
self.inPoller = poll()
self.inPoller.register(stdin)
self.inputFile = script
Cmd.__init__(self)
info('*** Starting CLI:\n')
if self.inputFile:
self.do_source(self.inputFile)
return
self.initReadline()
self.run()
def models(self, model=None, staMov=None, min_v=0, max_v=0, seed=None, stations=None, aps=None,
dstConn=None, srcConn=None, walls=None, plotNodes=None, MAX_X=0, MAX_Y=0):
np.random.seed(seed)
self.staList = stations
self.apList = aps
self.wallList = walls
nodes = self.staList + self.apList + plotNodes
# max waiting time
MAX_WT = 100.
for sta in self.staList:
if sta.max_x == 0:
sta.max_x = MAX_X
if sta.max_y == 0:
sta.max_y = MAX_Y
if sta.max_v == 0:
sta.max_v = max_v
if sta.min_v == 0:
sta.min_v = min_v
if self.DRAW:
plot2d.instantiateGraph(MAX_X, MAX_Y)
plot2d.plotGraph(nodes, srcConn, dstConn, MAX_X, MAX_Y)
plot2d.graphPause()
if staMov != None:
debug('Configuring the mobility model %s' % model)
if(model == 'RandomWalk'): # Random Walk model
mob = random_walk(staMov)
elif(model == 'TruncatedLevyWalk'): # Truncated Levy Walk model
mob = truncated_levy_walk(staMov)
elif(model == 'RandomDirection'): # Random Direction model
mob = random_direction(staMov, dimensions=(MAX_X, MAX_Y))
elif(model == 'RandomWayPoint'): # Random Waypoint model
mob = random_waypoint(staMov, wt_max=MAX_WT)
elif(model == 'GaussMarkov'): # Gauss-Markov model
mob = gauss_markov(staMov, alpha=0.99)
elif(model == 'ReferencePoint'): # Reference Point Group model
mob = reference_point_group(staMov, dimensions=(MAX_X, MAX_Y), aggregation=0.5)
elif(model == 'TimeVariantCommunity'): # Time-variant Community Mobility Model
mob = tvc(staMov, dimensions=(MAX_X, MAX_Y), aggregation=[0.5, 0.], epoch=[100, 100])
else:
raise Exception("Model not defined!")
if self.DRAW:
self.startMobilityModelGraph(mob, staMov)
else:
self.startMobilityModelNoGraph(mob, staMov)
def checkDimension(self, nodes):
try:
if self.is3d:
plot3d.instantiateGraph(self.MAX_X, self.MAX_Y, self.MAX_Z)
plot3d.graphInstantiateNodes(nodes)
else:
plot2d.instantiateGraph(self.MAX_X, self.MAX_Y)
plot2d.plotGraph(nodes, self.srcConn, self.dstConn)
plot2d.graphPause()
except:
info(
'Warning: This OS does not support GUI. Running without GUI.\n'
)
self.DRAW = False
def __init__(self, mininet, stdin=sys.stdin, script=None):
"""Start and run interactive or batch mode CLI
mininet: Mininet network object
stdin: standard input for CLI
script: script to run in batch mode"""
if mobility.isMobility == False and mobility.DRAW:
for sta in mininet.stations:
if 'position' not in sta.params:
sta.params['position'] = 0, 0, 0
if mobility.apList == []:
mobility.apList = mininet.accessPoints
if mobility.staList == []:
mobility.staList = mininet.stations
nodes = mininet.stations + mininet.accessPoints
if mininet.is3d:
plot3d.instantiateGraph(mininet.MAX_X, mininet.MAX_Y,
mininet.MAX_Z)
plot3d.graphInstantiateNodes(nodes)
else:
plot2d.instantiateGraph(mininet.MAX_X, mininet.MAX_Y)
plot2d.plotGraph(nodes, [], [], mininet.MAX_X, mininet.MAX_Y)
plot2d.graphPause()
self.mn = mininet
# Local variable bindings for py command
self.locals = {'net': mininet}
# Attempt to handle input
self.stdin = stdin
self.inPoller = poll()
self.inPoller.register(stdin)
self.inputFile = script
Cmd.__init__(self)
info('*** Starting CLI:\n')
if self.inputFile:
self.do_source(self.inputFile)
return
self.initReadline()
self.run()
def instantiateGraph(mininet):
MIN_X = mininetWiFi.MIN_X
MIN_Y = mininetWiFi.MIN_Y
MIN_Z = mininetWiFi.MIN_Z
MAX_X = mininetWiFi.MAX_X
MAX_Y = mininetWiFi.MAX_Y
MAX_Z = mininetWiFi.MAX_Z
nodes = mininet.stations + mininet.accessPoints
for node in nodes:
replayingMobility.addNode(node)
if MIN_Z != 0 or MAX_Z != 0:
plot3d.instantiateGraph(MIN_X, MIN_Y, MIN_Z, MAX_X, MAX_Y, MAX_Z)
plot3d.graphInstantiateNodes(nodes)
mininetWiFi.is3d = True
else:
plot2d.instantiateGraph(MIN_X, MIN_Y, MAX_X, MAX_Y)
plot2d.plotGraph(nodes)
def start(self, stations, aps, nroads, srcConn, dstConn, MAX_X, MAX_Y, **params):
'start topology'
cars = stations
mobility.addNodes(cars, aps)
[self.road.append(x) for x in range(0, nroads)]
[self.points.append(x) for x in range(0, nroads)]
[self.totalRoads.append(x) for x in range(0, nroads)]
plot2d.instantiateGraph(MAX_X, MAX_Y)
try:
self.display_grid(aps, srcConn, dstConn, nroads)
self.display_cars(cars)
plot2d.plotGraph(cars, [], [])
self.setWifiParameters()
while True:
[self.scatter, self.com_lines] = self.simulate_car_movement(cars, aps, self.scatter, self.com_lines)
mobility.continueParams
except:
pass
def __init__(self, cars, baseStations, nroads, srcConn, dstConn, MAX_X, MAX_Y):
mobility.staList = cars
mobility.apList = baseStations
mobility.MAX_X = MAX_X
mobility.MAX_Y = MAX_Y
[self.road.append(x) for x in range(0, nroads)]
[self.points.append(x) for x in range(0, nroads)]
[self.totalRoads.append(x) for x in range(0, nroads)]
plot2d.instantiateGraph(MAX_X, MAX_Y)
try:
self.display_grid(baseStations, srcConn, dstConn, nroads)
self.display_cars(cars)
plot2d.plotGraph(cars, [], [], MAX_X, MAX_Y)
self.setWifiParameters()
while mobility.continue_:
[self.scatter, self.com_lines] = self.simulate_car_movement(cars, baseStations, self.scatter, self.com_lines)
except:
pass
def start(self, **params):
'start topology'
from mininet.wifiMobility import mobility
cars = params['stations']
aps = params['aps']
mobility.addNodes(cars, aps)
[self.road.append(x) for x in range(0, params['nroads'])]
[self.points.append(x) for x in range(0, params['nroads'])]
[self.totalRoads.append(x) for x in range(0, params['nroads'])]
plot2d.instantiateGraph(params['MIN_X'], params['MIN_Y'],
params['MAX_X'], params['MAX_Y'])
self.display_grid(aps, params['connections'], params['nroads'])
self.display_cars(cars)
plot2d.plotGraph(cars, [])
self.setWifiParameters(mobility)
while True:
[self.scatter, self.com_lines] = \
self.simulate_car_movement(cars, aps, self.scatter,
self.com_lines, mobility)
mobility.continueParams
def __init__(self, cars, accessPoints, nroads, srcConn, dstConn, MAX_X,
MAX_Y):
mobility.addNodes(cars, accessPoints)
mobility.MAX_X = MAX_X
mobility.MAX_Y = MAX_Y
[self.road.append(x) for x in range(0, nroads)]
[self.points.append(x) for x in range(0, nroads)]
[self.totalRoads.append(x) for x in range(0, nroads)]
plot2d.instantiateGraph(MAX_X, MAX_Y)
try:
self.display_grid(accessPoints, srcConn, dstConn, nroads)
self.display_cars(cars)
plot2d.plotGraph(cars, [], [])
self.setWifiParameters()
while True:
[self.scatter, self.com_lines
] = self.simulate_car_movement(cars, accessPoints,
self.scatter, self.com_lines)
mobility.continueParams
except:
pass
def models(self, stations=None, aps=None, model=None, staMov=None, min_v=0, max_v=0, seed=None,
dstConn=None, srcConn=None, walls=None, plotNodes=None, MAX_X=0, MAX_Y=0):
"""
Used when a mobility model is applied
:param stations: list of stations
:param aps: list of access points
:param model: mobility model
:param staMov: list of nodes with mobility
:param min_v: minimum velocity
:param max_v: maximum velocity
:param speed: speed
:param srcConn: list of connections for source nodes
:param dstConn: list of connections for destination nodes
:param walls: list of walls (not used yet)
:param plotNodes: list of nodes to be plotted (including hosts and switches)
:param MAX_X: Maximum value for X
:param MAX_Y: Maximum value for Y
"""
np.random.seed(seed)
self.stations = stations
self.accessPoints = aps
self.wallList = walls
nodes = self.stations + self.accessPoints + plotNodes
# max waiting time
MAX_WT = 100.
for sta in self.stations:
if sta.max_x == 0:
sta.max_x = MAX_X
if sta.max_y == 0:
sta.max_y = MAX_Y
if sta.max_v == 0:
sta.max_v = max_v
if sta.min_v == 0:
sta.min_v = min_v
if self.DRAW:
plot2d.instantiateGraph(MAX_X, MAX_Y)
plot2d.plotGraph(nodes, srcConn, dstConn, MAX_X, MAX_Y)
plot2d.graphPause()
if staMov != None:
debug('Configuring the mobility model %s' % model)
if(model == 'RandomWalk'): # Random Walk model
mob = random_walk(staMov)
elif(model == 'TruncatedLevyWalk'): # Truncated Levy Walk model
mob = truncated_levy_walk(staMov)
elif(model == 'RandomDirection'): # Random Direction model
mob = random_direction(staMov, dimensions=(MAX_X, MAX_Y))
elif(model == 'RandomWayPoint'): # Random Waypoint model
mob = random_waypoint(staMov, wt_max=MAX_WT)
elif(model == 'GaussMarkov'): # Gauss-Markov model
mob = gauss_markov(staMov, alpha=0.99)
elif(model == 'ReferencePoint'): # Reference Point Group model
mob = reference_point_group(staMov, dimensions=(MAX_X, MAX_Y), aggregation=0.5)
elif(model == 'TimeVariantCommunity'): # Time-variant Community Mobility Model
mob = tvc(staMov, dimensions=(MAX_X, MAX_Y), aggregation=[0.5, 0.], epoch=[100, 100])
else:
raise Exception("Mobility Model not defined or doesn't exist!")
if self.DRAW:
self.startMobilityModelGraph(mob, staMov)
else:
self.startMobilityModelNoGraph(mob, staMov)
