| # 2015.03.12 10:28:21 PDT |
| #Embedded file name: ../tests/IntentPerfNextBM/IntentPerfNextBM.py |
| |
| |
| class IntentPerfNextBM: |
| |
| def __init__(self): |
| self.default = '' |
| |
| def CASE1(self, main): |
| """ |
| ONOS startup sequence |
| """ |
| global clusterCount |
| global timeToPost |
| global runNum |
| import time |
| |
| clusterCount = 1 |
| timeToPost = time.strftime('%Y-%m-%d %H:%M:%S') |
| runNum = time.strftime('%d%H%M%S') |
| cellName = main.params['ENV']['cellName'] |
| gitPull = main.params['GIT']['autoPull'] |
| checkoutBranch = main.params['GIT']['checkout'] |
| intentFilePath = main.params['DB']['intentFilePath'] |
| cellStr = main.params[ 'TEST' ][ 'cellStr' ] |
| ONOSIp = [] |
| |
| for i in range(1, 8): |
| ONOSIp.append(main.params['CTRL']['ip' + str(i)]) |
| main.ONOSbench.onosUninstall(nodeIp=ONOSIp[i - 1]) |
| |
| MN1Ip = main.params['MN']['ip1'] |
| BENCHIp = main.params['BENCH']['ip'] |
| main.case('Setting up test environment') |
| main.step('Clearing previous DB log file') |
| fIntentLog = open(intentFilePath, 'w') |
| fIntentLog.write('') |
| fIntentLog.close() |
| main.step('Starting mininet topology') |
| main.Mininet1.startNet() |
| main.step('Creating cell file') |
| cellFileResult = main.ONOSbench.createCellFile( |
| BENCHIp, cellName, MN1Ip, cellStr, ONOSIp[0]) |
| main.step('Applying cell file to environment') |
| cellApplyResult = main.ONOSbench.setCell(cellName) |
| verifyCellResult = main.ONOSbench.verifyCell() |
| main.step('Removing raft logs') |
| main.ONOSbench.onosRemoveRaftLogs() |
| main.step('Git checkout and pull ' + checkoutBranch) |
| |
| if gitPull == 'on': |
| checkoutResult = main.ONOSbench.gitCheckout(checkoutBranch) |
| pullResult = main.ONOSbench.gitPull() |
| main.step('Using onos-build to compile ONOS') |
| buildResult = main.ONOSbench.onosBuild() |
| else: |
| checkoutResult = main.TRUE |
| pullResult = main.TRUE |
| buildResult = main.TRUE |
| main.log.info('Git pull skipped by configuration') |
| |
| main.log.report('Commit information - ') |
| main.ONOSbench.getVersion(report=True) |
| main.step('Creating ONOS package') |
| packageResult = main.ONOSbench.onosPackage() |
| main.step('Installing ONOS package') |
| install1Result = main.ONOSbench.onosInstall(node=ONOSIp[0]) |
| main.step('Set cell for ONOScli env') |
| main.ONOS1cli.setCell(cellName) |
| time.sleep(5) |
| main.step('Start onos cli') |
| cli1 = main.ONOS1cli.startOnosCli(ONOSIp[0]) |
| utilities.assert_equals(expect=main.TRUE, |
| actual=cellFileResult and cellApplyResult and\ |
| verifyCellResult and checkoutResult and\ |
| pullResult and buildResult and install1Result, |
| onpass='ONOS started successfully', |
| onfail='Failed to start ONOS') |
| |
| def CASE2(self, main): |
| """ |
| Batch intent install |
| |
| Supports scale-out scenarios and increasing |
| number of intents within each iteration |
| """ |
| import time |
| import json |
| import requests |
| import os |
| import numpy |
| ONOS1Ip = main.params['CTRL']['ip1'] |
| ONOS2Ip = main.params['CTRL']['ip2'] |
| ONOS3Ip = main.params['CTRL']['ip3'] |
| ONOS4Ip = main.params['CTRL']['ip4'] |
| ONOS5Ip = main.params['CTRL']['ip5'] |
| ONOS6Ip = main.params['CTRL']['ip6'] |
| ONOS7Ip = main.params['CTRL']['ip7'] |
| assertion = main.TRUE |
| ONOSIpList = [] |
| |
| for i in range(1, 8): |
| ONOSIpList.append(main.params['CTRL']['ip' + str(i)]) |
| |
| ONOSUser = main.params['CTRL']['user'] |
| defaultSwPort = main.params['CTRL']['port1'] |
| batchIntentSize = int(main.params['TEST']['batchIntentSize']) |
| batchThreshMin = int(main.params['TEST']['batchThresholdMin']) |
| batchThreshMax = int(main.params['TEST']['batchThresholdMax']) |
| numIter = main.params['TEST']['numIter'] |
| numIgnore = int(main.params['TEST']['numIgnore']) |
| numSwitch = int(main.params['TEST']['numSwitch']) |
| nThread = main.params['TEST']['numMult'] |
| intentFilePath = main.params['DB']['intentFilePath'] |
| |
| if clusterCount == 1: |
| for i in range(1, numSwitch + 1): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS1Ip, port=defaultSwPort) |
| if clusterCount == 3: |
| for i in range(1, 3): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS1Ip, port=defaultSwPort) |
| for i in range(3, 6): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS2Ip, port=defaultSwPort) |
| for i in range(6, 9): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS3Ip, port=defaultSwPort) |
| if clusterCount == 5: |
| main.Mininet1.assignSwController(sw='s1', |
| ip=ONOS1Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s2', |
| ip=ONOS2Ip, port=defaultSwPort) |
| for i in range(3, 6): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS3Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s6', |
| ip=ONOS4Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s7', |
| ip=ONOS5Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s8', |
| ip=ONOS5Ip, port=defaultSwPort) |
| if clusterCount == 7: |
| for i in range(1, 9): |
| if i < 8: |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOSIpList[i - 1], port=defaultSwPort) |
| elif i >= 8: |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOSIpList[6], port=defaultSwPort) |
| |
| time.sleep(20) |
| |
| deviceIdList = [] |
| batchInstallLat = [] |
| batchWithdrawLat = [] |
| |
| main.log.report('Batch intent installation test of ' + |
| str(batchIntentSize) + ' intent(s)') |
| main.log.info('Getting list of available devices') |
| |
| jsonStr = main.ONOS1cli.devices() |
| jsonObj = json.loads(jsonStr) |
| for device in jsonObj: |
| deviceIdList.append(device['id']) |
| |
| if not jsonObj: |
| main.log.warn( "Devices not found, check topology" ) |
| |
| sleepTime = 10 |
| baseDir = '/tmp/' |
| for batch in range(0, 5): |
| maxInstallLat = [] |
| maxWithdrawLat = [] |
| maxSingleInstallLat = [] |
| maxSingleWithdrawLat = [] |
| for i in range(0, int(numIter)): |
| main.log.info('Pushing ' + str( |
| int(batchIntentSize) * int(nThread)) + |
| ' intents. Iteration ' + str(i)) |
| saveDir = baseDir + 'batch_intent_1.txt' |
| main.ONOSbench.pushTestIntentsShell(deviceIdList[0] + |
| '/2', deviceIdList[7] + '/2', batchIntentSize, |
| saveDir, ONOSIpList[0], numMult=nThread) |
| time.sleep(sleepTime) |
| intent = '' |
| counter = 300 |
| while len(intent) > 0 and counter > 0: |
| main.ONOS1cli.handle.sendline('intents | wc -l') |
| main.ONOS1cli.handle.expect('intents | wc -l') |
| main.ONOS1cli.handle.expect('onos>') |
| intentTemp = main.ONOS1cli.handle.before() |
| intent = main.ONOS1cli.intents() |
| intent = json.loads(intent) |
| counter = counter - 1 |
| time.sleep(1) |
| |
| time.sleep(5) |
| saveDir = baseDir + 'batch_intent_1.txt' |
| with open(saveDir) as fOnos: |
| lineCount = 0 |
| for line in fOnos: |
| line_temp = '' |
| main.log.info('Line read: ' + str(line)) |
| line_temp = line[1:] |
| line_temp = line_temp.split(': ') |
| if ' ' in str(line_temp): |
| result = line_temp[1].split(' ')[0] |
| else: |
| main.log.warn('Empty line read') |
| result = 0 |
| if lineCount == 0: |
| if 'Failure' in str(line): |
| main.log.warn('Intent installation failed') |
| result = 'NA' |
| else: |
| main.log.info('Install result: ' + result) |
| batchInstallLat.append(int(result)) |
| installResult = result |
| elif lineCount == 1: |
| if 'Failure' in str(line): |
| main.log.warn('Intent withdraw failed') |
| result = 'NA' |
| else: |
| main.log.info('Withdraw result: ' + result) |
| batchWithdrawLat.append(int(result)) |
| withdrawResult = result |
| else: |
| main.log.warn('Invalid results') |
| installResult = 'NA' |
| withdrawResult = 'NA' |
| lineCount += 1 |
| |
| main.log.info('Batch install latency with' + |
| str(batchIntentSize) + 'intents: ' + |
| str(installResult) + ' ms') |
| main.log.info('Batch withdraw latency with' + |
| str(batchIntentSize) + 'intents: ' + |
| str(withdrawResult) + ' ms') |
| main.log.info('Single intent install latency with' + |
| str(batchIntentSize) + 'intents: ' + |
| str(float(installResult) / int(batchIntentSize))+' ms') |
| main.log.info('Single intent withdraw latency with' + |
| str(batchIntentSize) + 'intents: ' + |
| str(float(withdrawResult)/ int(batchIntentSize))+' ms') |
| if len(batchInstallLat) > 0 and int(i) > numIgnore: |
| maxInstallLat.append(max(batchInstallLat)) |
| maxSingleInstallLat.append( |
| max(batchInstallLat) / int(batchIntentSize)) |
| elif len(batchInstallLat) == 0: |
| sleepTime += 30 |
| if len(batchWithdrawLat) > 0 and int(i) > numIgnore: |
| maxWithdrawLat.append(max(batchWithdrawLat)) |
| maxSingleWithdrawLat.append( |
| max(batchWithdrawLat) / int(batchIntentSize)) |
| batchInstallLat = [] |
| batchWithdrawLat = [] |
| time.sleep(5) |
| |
| if maxInstallLat: |
| avgInstallLat = str(round( |
| numpy.average(maxInstallLat), 2)) |
| stdInstallLat = str(round( |
| numpy.std(maxInstallLat), 2)) |
| avgSingleInstallLat = str(round( |
| numpy.average(maxSingleInstallLat), 3)) |
| stdSingleInstallLat = str(round( |
| numpy.std(maxSingleInstallLat), 3)) |
| else: |
| avgInstallLat = 'NA' |
| stdInstallLat = 'NA' |
| main.log.report('Batch installation failed') |
| assertion = main.FALSE |
| if maxWithdrawLat: |
| avgWithdrawLat = str(round( |
| numpy.average(maxWithdrawLat), 2)) |
| stdWithdrawLat = str(round( |
| numpy.std(maxWithdrawLat), 2)) |
| avgSingleWithdrawLat = str(round( |
| numpy.average(maxSingleWithdrawLat), 3)) |
| stdSingleWithdrawLat = str(round( |
| numpy.std(maxSingleWithdrawLat), 3)) |
| else: |
| avgWithdrawLat = 'NA' |
| stdWithdrawLat = 'NA' |
| main.log.report('Batch withdraw failed') |
| assertion = main.FALSE |
| |
| main.log.report('Avg of batch installation latency ' + |
| 'of size ' + str(batchIntentSize) + ': ' + |
| str(avgInstallLat) + ' ms') |
| main.log.report('Std Deviation of batch installation latency ' + |
| ': ' + str(round(numpy.std(maxInstallLat), 2)) + ' ms') |
| main.log.report('Avg of batch withdraw latency ' + |
| 'of size ' + str(batchIntentSize) + ': ' + |
| str(avgWithdrawLat) + ' ms') |
| main.log.report('Std Deviation of batch withdraw latency ' + |
| ': ' + str(round(numpy.std(maxWithdrawLat), 2)) + ' ms') |
| |
| main.log.report('Avg of batch withdraw latency ' + 'of size ' + |
| str(batchIntentSize) + ': ' + str(avgWithdrawLat) + ' ms') |
| main.log.report('Std Deviation of batch withdraw latency ' + |
| ': ' + str(stdWithdrawLat) + ' ms') |
| main.log.report('Avg of single withdraw latency ' + 'of size ' + |
| str(batchIntentSize) + ': ' + |
| str(avgSingleWithdrawLat) + ' ms') |
| main.log.report('Std Deviation of single withdraw latency ' + |
| ': ' + str(stdSingleWithdrawLat) + ' ms') |
| |
| dbCmd = "INSERT INTO intents_latency_tests VALUES('" +\ |
| timeToPost + "','intents_latency_results'," +\ |
| runNum + ',' + str(clusterCount) + ',' +\ |
| str(batchIntentSize) + ',' + str(avgInstallLat) +\ |
| ',' + str(stdInstallLat) + ',' + str(avgWithdrawLat) +\ |
| ',' + str(stdWithdrawLat) + ');' |
| |
| fResult = open(intentFilePath, 'a') |
| if dbCmd: |
| fResult.write(dbCmd + '\n') |
| fResult.close() |
| if batch == 0: |
| batchIntentSize = 10 |
| elif batch == 1: |
| batchIntentSize = 100 |
| elif batch == 2: |
| batchIntentSize = 1000 |
| elif batch == 3: |
| batchIntentSize = 1500 |
| if batch < 4: |
| main.log.report('Increasing batch intent size to ' + |
| str(batchIntentSize)) |
| |
| utilities.assert_equals(expect=main.TRUE, actual=assertion, |
| onpass='Batch intent install/withdraw test successful', |
| onfail='Batch intent install/withdraw test failed') |
| |
| def CASE3(self, main): |
| """ |
| Batch intent reroute latency |
| """ |
| import time |
| import json |
| import requests |
| import os |
| import numpy |
| |
| ONOS1Ip = main.params['CTRL']['ip1'] |
| ONOS2Ip = main.params['CTRL']['ip2'] |
| ONOS3Ip = main.params['CTRL']['ip3'] |
| ONOS4Ip = main.params['CTRL']['ip4'] |
| ONOS5Ip = main.params['CTRL']['ip5'] |
| ONOS6Ip = main.params['CTRL']['ip6'] |
| ONOS7Ip = main.params['CTRL']['ip7'] |
| |
| ONOSIpList = [] |
| for i in range(1, 8): |
| ONOSIpList.append(main.params['CTRL']['ip' + str(i)]) |
| |
| ONOSUser = main.params['CTRL']['user'] |
| defaultSwPort = main.params['CTRL']['port1'] |
| batchIntentSize = main.params['TEST']['batchIntentSize'] |
| thresholdMin = int(main.params['TEST']['batchThresholdMin']) |
| thresholdMax = int(main.params['TEST']['batchThresholdMax']) |
| |
| intfs = main.params['TEST']['intfs'] |
| installTime = main.params['JSON']['installedTime'] |
| numIter = main.params['TEST']['numIter'] |
| numIgnore = int(main.params['TEST']['numIgnore']) |
| numSwitch = int(main.params['TEST']['numSwitch']) |
| nThread = main.params['TEST']['numMult'] |
| |
| tsharkPortStatus = main.params[ 'TSHARK' ][ 'ofpPortStatus' ] |
| tsharkPortDown = '/tmp/tshark_port_down_reroute.txt' |
| |
| if clusterCount == 1: |
| for i in range(1, numSwitch + 1): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS1Ip, port=defaultSwPort) |
| if clusterCount == 3: |
| for i in range(1, 3): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS1Ip, port=defaultSwPort) |
| for i in range(3, 6): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS2Ip, port=defaultSwPort) |
| for i in range(6, 9): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS3Ip, port=defaultSwPort) |
| if clusterCount == 5: |
| main.Mininet1.assignSwController(sw='s1', |
| ip=ONOS1Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s2', |
| ip=ONOS2Ip, port=defaultSwPort) |
| for i in range(3, 6): |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOS3Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s6', |
| ip=ONOS4Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s7', |
| ip=ONOS5Ip, port=defaultSwPort) |
| main.Mininet1.assignSwController(sw='s8', |
| ip=ONOS5Ip, port=defaultSwPort) |
| if clusterCount == 7: |
| for i in range(1, 9): |
| if i < 8: |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOSIpList[i - 1], port=defaultSwPort) |
| elif i >= 8: |
| main.Mininet1.assignSwController(sw="s" + str(i), |
| ip=ONOSIpList[6], port=defaultSwPort) |
| |
| main.log.report('Batch intent reroute test ') |
| |
| batchIntentRerouteAvgSystem = numpy.zeros(( |
| clusterCount, int(numIter))) |
| batchIntentRerouteStdSystem = numpy.zeros(( |
| clusterCount, int(numIter))) |
| batchIntentRerouteAvgPort = numpy.zeros(( |
| clusterCount, int(numIter))) |
| batchIntentRerouteStdSystem = numpy.zeros(( |
| clusterCount, int(numIter))) |
| |
| time.sleep(10) |
| |
| main.log.info('Getting list of available devices') |
| |
| deviceIdList = [] |
| jsonStr = main.ONOS1cli.devices() |
| jsonObj = json.loads(jsonStr) |
| for device in jsonObj: |
| deviceIdList.append(device['id']) |
| if not jsonObj: |
| main.log.warn('No devices have been discovered') |
| assertion = main.FALSE |
| |
| sleepTime = 10 |
| |
| baseDir = '/tmp/' |
| for batch in range(0, 5): |
| maxRerouteLatSystem = [] |
| maxRerouteLatPort = [] |
| for i in range(0, int(numIter)): |
| rerouteLatSystem = [] |
| rerouteLatPort = [] |
| main.log.info('Pushing ' + str( |
| int(batchIntentSize) * int(nThread)) + |
| ' intents. Iteration ' + str(i)) |
| main.ONOSbench.pushTestIntentsShell( |
| deviceIdList[0] + '/2', deviceIdList[7] + |
| '/2', batchIntentSize, '/tmp/batch_install.txt', |
| ONOSIpList[0], numMult='1', report=False, |
| options='-i') |
| |
| time.sleep(10) |
| |
| main.ONOS1.tsharkGrep(tsharkPortStatus, tsharkPortDown) |
| main.log.info('Disabling interface ' + intfs) |
| main.Mininet1.handle.sendline( |
| 'sh ifconfig ' + intfs + ' down') |
| t0System = time.time() * 1000 |
| |
| time.sleep(3) |
| |
| main.ONOS1.tsharkStop() |
| |
| time.sleep(2) |
| |
| os.system('scp ' + ONOSUser + '@' + ONOSIpList[0] + |
| ':' + tsharkPortDown + ' /tmp/') |
| time.sleep(5) |
| |
| fPortDown = open(tsharkPortDown, 'r') |
| fLine = fPortDown.readline() |
| objDown = fLine.split(' ') |
| if len(fLine) > 0: |
| timestampBeginPtDown = int(float(objDown[1]) * 1000) |
| if timestampBeginPtDown < 1400000000000: |
| timestampBeginPtDown = int(float(objDown[2]) * 1000) |
| main.log.info('Port down begin timestamp: ' + |
| str(timestampBeginPtDown)) |
| else: |
| main.log.info('Tshark output file returned unexpected' + |
| ' results: ' + str(fLine)) |
| fPortDown.close() |
| |
| intentsJsonStr1 = main.ONOS1cli.intentsEventsMetrics() |
| intentsJsonObj1 = json.loads(intentsJsonStr1) |
| intentInstall1 = intentsJsonObj1[installTime]['value'] |
| intentRerouteLat1 = int(intentInstall1) - int(t0System) |
| intentRerouteLatPort1 =\ |
| int(intentInstall1) - int(timestampBeginPtDown) |
| |
| if intentRerouteLat1 > thresholdMin and \ |
| intentRerouteLat1 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat1) |
| main.log.info('ONOS1 Intent Reroute Lat ' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + |
| str(intentRerouteLat1) + ' ms') |
| if intentRerouteLatPort1 > thresholdMin and\ |
| intentRerouteLatPort1 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort1) |
| |
| main.log.info('ONOS1 Intent Reroute Lat ' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + |
| str(intentRerouteLatPort1) + ' ms') |
| |
| if clusterCount == 3: |
| intentsJsonStr2 = main.ONOS2cli.intentsEventsMetrics() |
| intentsJsonStr3 = main.ONOS3cli.intentsEventsMetrics() |
| intentsJsonObj2 = json.loads(intentsJsonStr2) |
| intentsJsonObj3 = json.loads(intentsJsonStr3) |
| intentInstall2 = intentsJsonObj2[installTime]['value'] |
| intentInstall3 = intentsJsonObj3[installTime]['value'] |
| intentRerouteLat2 = int(intentInstall2) - int(t0System) |
| intentRerouteLat3 = int(intentInstall3) - int(t0System) |
| intentRerouteLatPort2 = int(intentInstall2) - int(timestampBeginPtDown) |
| intentRerouteLatPort3 = int(intentInstall3) - int(timestampBeginPtDown) |
| |
| if intentRerouteLat2 > thresholdMin and\ |
| intentRerouteLat2 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat2) |
| main.log.info('ONOS2 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + str(intentRerouteLat2) + ' ms') |
| if intentRerouteLat3 > thresholdMin and\ |
| intentRerouteLat3 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat3) |
| main.log.info('ONOS3 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + str(intentRerouteLat3) + |
| ' ms') |
| if intentRerouteLatPort2 > thresholdMin and\ |
| intentRerouteLatPort2 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort2) |
| main.log.info('ONOS2 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' port-to-install: ' + |
| str(intentRerouteLatPort2) + ' ms') |
| if intentRerouteLatPort3 > thresholdMin and\ |
| intentRerouteLatPort3 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort3) |
| main.log.info('ONOS3 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' port-to-install: ' + |
| str(intentRerouteLatPort2) + ' ms') |
| |
| if clusterCount == 5: |
| intentsJsonStr4 = main.ONOS4cli.intentsEventsMetrics() |
| intentsJsonStr5 = main.ONOS5cli.intentsEventsMetrics() |
| intentsJsonObj4 = json.loads(intentsJsonStr4) |
| intentsJsonObj5 = json.loads(intentsJsonStr5) |
| intentInstall4 = intentsJsonObj4[installTime]['value'] |
| intentInstall5 = intentsJsonObj5[installTime]['value'] |
| intentRerouteLat4 = int(intentInstall4) - int(t0System) |
| intentRerouteLat5 = int(intentInstall5) - int(t0System) |
| intentRerouteLatPort4 =\ |
| int(intentInstall4) - int(timestampBeginPtDown) |
| intentRerouteLatPort5 =\ |
| int(intentInstall5) - int(timestampBeginPtDown) |
| if intentRerouteLat4 > thresholdMin and\ |
| intentRerouteLat4 < thresholdMax and \ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat4) |
| main.log.info('ONOS4 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + str(intentRerouteLat4) + |
| ' ms') |
| if intentRerouteLat5 > thresholdMin and\ |
| intentRerouteLat5 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat5) |
| main.log.info('ONOS5 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + |
| str(intentRerouteLat5) + ' ms') |
| if intentRerouteLatPort4 > thresholdMin and\ |
| intentRerouteLatPort4 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort4) |
| main.log.info('ONOS4 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' port-to-install: ' + |
| str(intentRerouteLatPort4) + ' ms') |
| if intentRerouteLatPort5 > thresholdMin and\ |
| intentRerouteLatPort5 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort5) |
| main.log.info('ONOS5 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' port-to-install: ' + |
| str(intentRerouteLatPort5) + ' ms') |
| |
| if clusterCount == 7: |
| intentsJsonStr6 = main.ONOS6cli.intentsEventsMetrics() |
| intentsJsonStr7 = main.ONOS7cli.intentsEventsMetrics() |
| intentsJsonObj6 = json.loads(intentsJsonStr6) |
| intentsJsonObj7 = json.loads(intentsJsonStr7) |
| intentInstall6 = intentsJsonObj6[installTime]['value'] |
| intentInstall7 = intentsJsonObj7[installTime]['value'] |
| intentRerouteLat6 = int(intentInstall6) - int(t0System) |
| intentRerouteLat7 = int(intentInstall7) - int(t0System) |
| intentRerouteLatPort4 =\ |
| int(intentInstall4) - int(timestampBeginPtDown) |
| intentRerouteLatPort5 =\ |
| int(intentInstall5) - int(timestampBeginPtDown) |
| if intentRerouteLat6 > thresholdMin and\ |
| intentRerouteLat6 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat6) |
| main.log.info('ONOS6 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + |
| str(intentRerouteLat6) + ' ms') |
| if intentRerouteLat7 > thresholdMin and\ |
| intentRerouteLat7 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatSystem.append(intentRerouteLat7) |
| main.log.info('ONOS7 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' system-to-install: ' + |
| str(intentRerouteLat7) + ' ms') |
| if intentRerouteLatPort6 > thresholdMin and\ |
| intentRerouteLatPort6 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort6) |
| main.log.info('ONOS6 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' port-to-install: ' + |
| str(intentRerouteLatPort6) + ' ms') |
| if intentRerouteLatPort7 > thresholdMin and\ |
| intentRerouteLatPort7 < thresholdMax and\ |
| i > numIgnore: |
| rerouteLatPort.append(intentRerouteLatPort7) |
| main.log.info('ONOS7 Intent Reroute Lat' + |
| ' size: ' + str(batchIntentSize) + |
| ' port-to-install: ' + |
| str(intentRerouteLatPort7) + ' ms') |
| |
| time.sleep(5) |
| |
| main.log.info('System: ' + str(rerouteLatSystem)) |
| main.log.info('Port: ' + str(rerouteLatPort)) |
| if rerouteLatSystem: |
| maxRerouteLatSystem = max(rerouteLatSystem) |
| main.log.info('Max system: ' + str(maxRerouteLatSystem)) |
| if rerouteLatPort: |
| maxRerouteLatPort = max(rerouteLatPort) |
| main.log.info('Max port: ' + str(maxRerouteLatPort)) |
| |
| # Bring port back up for next iteration |
| main.Mininet1.handle.sendline('sh ifconfig ' + intfs + ' up') |
| time.sleep(5) |
| |
| # Use 'withdraw' option to withdraw batch intents |
| main.ONOSbench.pushTestIntentsShell( |
| deviceIdList[0] + '/2', deviceIdList[7] + '/2', |
| batchIntentSize, '/tmp/batch_install.txt', |
| ONOSIpList[0], numMult='1', report=False, options='-w') |
| main.log.info('Intents removed and port back up') |
| |
| # NOTE: End iteration loop |
| if batch == 1: |
| batchIntentSize = 10 |
| elif batch == 2: |
| batchIntentSize = 100 |
| elif batch == 3: |
| batchIntentSize = 500 |
| elif batch == 4: |
| batchIntentSize = 1000 |
| main.log.info('Batch intent size increased to ' + str(batchIntentSize)) |
| |
| def CASE4(self, main): |
| """ |
| Increase number of nodes and initiate CLI |
| """ |
| global clusterCount |
| import time |
| import json |
| |
| clusterCount += 2 |
| |
| cellName = main.params[ 'ENV' ][ 'cellName' ] |
| features = main.params[ 'TEST' ][ 'cellStr' ] |
| benchIp = main.params[ 'BENCH' ][ 'ip' ] |
| mininetIp = main.params[ 'MN' ][ 'ip1' ] |
| |
| main.log.report('Increasing cluster size to ' + str(clusterCount)) |
| |
| ONOSIp = [] |
| for i in range( 1, 8 ): |
| ONOSIp.append( main.params[ 'CTRL' ][ 'ip'+str(i) ] ) |
| |
| main.step( "Cleaning environment" ) |
| for i in range( 0, 7 ): |
| main.ONOSbench.onosDie( ONOSIp[i] ) |
| main.log.info( "Uninstalling ONOS "+str(i+1) ) |
| main.ONOSbench.onosUninstall( ONOSIp[i] ) |
| |
| main.step( "Creating new cell file" ) |
| cellIp = [] |
| for node in range( 1, clusterCount + 1 ): |
| cellIp.append( ONOSIp[node] ) |
| main.ONOSbench.createCellFile( benchIp, cellName, |
| mininetIp, str(features), *cellIp ) |
| |
| main.step( "Setting cell definition" ) |
| main.ONOSbench.setCell( cellName ) |
| |
| main.step( "Packaging cell definition" ) |
| main.ONOSbench.onosPackage() |
| |
| for node in range( 1, clusterCount + 1 ): |
| main.ONOSbench.onosInstall( node = ONOSIp[node] ) |
| |
| time.sleep( 20 ) |
| |
| for node in range( 1, clusterCount + 1 ): |
| for i in range( 2 ): |
| isup = main.ONOSbench.isup( ONOSIp[node] ) |
| if isup: |
| main.log.info( "ONOS "+str(node) + " is up\n") |
| assertion = main.TRUE |
| break |
| if not isup: |
| main.log.info( "ONOS" + str(node) + " did not start") |
| |
| for node in range( 1, clusterCount + 1 ): |
| exec "a = main.ONOS%scli.startOnosCli" %str(node) |
| a( ONOSIp[node] ) |
| |
| time.sleep(30) |
| |
| utilities.assert_equals(expect=main.TRUE, actual=assertion, |
| onpass='Scale out to ' + str(clusterCount) + ' nodes successful', |
| onfail='Scale out to ' + str(clusterCount) + ' nodes failed') |
| |