Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 1 | import multiprocessing |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 2 | import os |
Carmelo Cascone | 977ae3f | 2016-06-23 19:28:28 -0700 | [diff] [blame] | 3 | import socket |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 4 | import re |
| 5 | import json |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 6 | import threading |
Brian O'Connor | 71167f9 | 2017-06-16 14:55:00 -0700 | [diff] [blame] | 7 | import urllib2 |
Carmelo Cascone | 977ae3f | 2016-06-23 19:28:28 -0700 | [diff] [blame] | 8 | |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 9 | import time |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 10 | from contextlib import closing |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 11 | |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 12 | from mininet.log import info, warn, error |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 13 | from mininet.node import Switch, Host |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 14 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 15 | SIMPLE_SWITCH_GRPC = 'simple_switch_grpc' |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 16 | PKT_BYTES_TO_DUMP = 80 |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 17 | VALGRIND_PREFIX = 'valgrind --leak-check=yes' |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 18 | SWITCH_START_TIMEOUT = 5 # seconds |
| 19 | BMV2_LOG_LINES = 5 |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 20 | BMV2_DEFAULT_DEVICE_ID = 0 |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 21 | |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 22 | |
| 23 | def parseBoolean(value): |
| 24 | if value in ['1', 1, 'true', 'True']: |
| 25 | return True |
| 26 | else: |
| 27 | return False |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 28 | |
| 29 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 30 | def pickUnusedPort(): |
| 31 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| 32 | s.bind(('localhost', 0)) |
| 33 | addr, port = s.getsockname() |
| 34 | s.close() |
| 35 | return port |
| 36 | |
| 37 | |
| 38 | def writeToFile(path, value): |
| 39 | with open(path, "w") as f: |
| 40 | f.write(str(value)) |
| 41 | |
| 42 | |
| 43 | def watchDog(sw): |
| 44 | while True: |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 45 | if ONOSBmv2Switch.mininet_exception == 1: |
| 46 | sw.killBmv2(log=False) |
| 47 | return |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 48 | if sw.stopped: |
| 49 | return |
| 50 | with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s: |
| 51 | if s.connect_ex(('127.0.0.1', sw.grpcPort)) == 0: |
| 52 | time.sleep(1) |
| 53 | else: |
Carmelo Cascone | df32bea | 2018-06-19 17:45:54 +0200 | [diff] [blame] | 54 | warn("\n*** WARN: BMv2 instance %s died!\n" % sw.name) |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 55 | sw.printBmv2Log() |
| 56 | print ("-" * 80) + "\n" |
| 57 | return |
| 58 | |
| 59 | |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 60 | class ONOSHost(Host): |
| 61 | def __init__(self, name, inNamespace=True, **params): |
| 62 | Host.__init__(self, name, inNamespace=inNamespace, **params) |
| 63 | |
| 64 | def config(self, **params): |
| 65 | r = super(Host, self).config(**params) |
| 66 | for off in ["rx", "tx", "sg"]: |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 67 | cmd = "/sbin/ethtool --offload %s %s off" \ |
Carmelo Cascone | 6ec8f8f | 2017-11-22 14:27:06 -0800 | [diff] [blame] | 68 | % (self.defaultIntf(), off) |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 69 | self.cmd(cmd) |
| 70 | # disable IPv6 |
| 71 | self.cmd("sysctl -w net.ipv6.conf.all.disable_ipv6=1") |
| 72 | self.cmd("sysctl -w net.ipv6.conf.default.disable_ipv6=1") |
| 73 | self.cmd("sysctl -w net.ipv6.conf.lo.disable_ipv6=1") |
| 74 | return r |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 75 | |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 76 | |
| 77 | class ONOSBmv2Switch(Switch): |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 78 | """BMv2 software switch with gRPC server""" |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 79 | # Shared value used to notify to all instances of this class that a Mininet |
| 80 | # exception occurred. Mininet exception handling doesn't call the stop() |
| 81 | # method, so the mn process would hang after clean-up since Bmv2 would still |
| 82 | # be running. |
| 83 | mininet_exception = multiprocessing.Value('i', 0) |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 84 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 85 | def __init__(self, name, json=None, debugger=False, loglevel="warn", |
Carmelo Cascone | eaa8b1d | 2018-04-11 14:12:17 -0700 | [diff] [blame] | 86 | elogger=False, grpcport=None, cpuport=255, |
| 87 | thriftport=None, netcfg=True, dryrun=False, pipeconf="", |
| 88 | pktdump=False, valgrind=False, gnmi=False, |
Carmelo Cascone | 55965c6 | 2018-05-17 18:13:16 -0700 | [diff] [blame] | 89 | portcfg=True, onosdevid=None, **kwargs): |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 90 | Switch.__init__(self, name, **kwargs) |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 91 | self.grpcPort = grpcport |
| 92 | self.thriftPort = thriftport |
Carmelo Cascone | eaa8b1d | 2018-04-11 14:12:17 -0700 | [diff] [blame] | 93 | self.cpuPort = cpuport |
Carmelo Cascone | fb76b04 | 2017-07-17 19:42:00 -0400 | [diff] [blame] | 94 | self.json = json |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 95 | self.debugger = parseBoolean(debugger) |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 96 | self.loglevel = loglevel |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 97 | # Important: Mininet removes all /tmp/*.log files in case of exceptions. |
| 98 | # We want to be able to see the bmv2 log if anything goes wrong, hence |
| 99 | # avoid the .log extension. |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 100 | self.logfile = '/tmp/bmv2-%s-log' % self.name |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 101 | self.elogger = parseBoolean(elogger) |
| 102 | self.pktdump = parseBoolean(pktdump) |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 103 | self.netcfg = parseBoolean(netcfg) |
| 104 | self.dryrun = parseBoolean(dryrun) |
| 105 | self.valgrind = parseBoolean(valgrind) |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 106 | self.netcfgfile = '/tmp/bmv2-%s-netcfg.json' % self.name |
Carmelo Cascone | eaa8b1d | 2018-04-11 14:12:17 -0700 | [diff] [blame] | 107 | self.pipeconfId = pipeconf |
| 108 | self.injectPorts = parseBoolean(portcfg) |
| 109 | self.withGnmi = parseBoolean(gnmi) |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 110 | self.longitude = kwargs['longitude'] if 'longitude' in kwargs else None |
| 111 | self.latitude = kwargs['latitude'] if 'latitude' in kwargs else None |
Carmelo Cascone | 55965c6 | 2018-05-17 18:13:16 -0700 | [diff] [blame] | 112 | if onosdevid is not None and len(onosdevid) > 0: |
| 113 | self.onosDeviceId = onosdevid |
| 114 | else: |
| 115 | self.onosDeviceId = "device:bmv2:%s" % self.name |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 116 | self.logfd = None |
| 117 | self.bmv2popen = None |
| 118 | self.stopped = False |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 119 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 120 | # Remove files from previous executions |
| 121 | self.cleanupTmpFiles() |
| 122 | |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 123 | def getSourceIp(self, dstIP): |
| 124 | """ |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 125 | Queries the Linux routing table to get the source IP that can talk with |
| 126 | dstIP, and vice versa. |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 127 | """ |
| 128 | ipRouteOut = self.cmd('ip route get %s' % dstIP) |
| 129 | r = re.search(r"src (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})", ipRouteOut) |
| 130 | return r.group(1) if r else None |
| 131 | |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 132 | def getDeviceConfig(self, srcIP): |
Carmelo Cascone | 2cad9ef | 2017-08-01 21:52:07 +0200 | [diff] [blame] | 133 | |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 134 | basicCfg = { |
| 135 | "driver": "bmv2" |
| 136 | } |
| 137 | |
| 138 | if self.longitude and self.latitude: |
| 139 | basicCfg["longitude"] = self.longitude |
| 140 | basicCfg["latitude"] = self.latitude |
| 141 | |
| 142 | cfgData = { |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 143 | "generalprovider": { |
| 144 | "p4runtime": { |
| 145 | "ip": srcIP, |
| 146 | "port": self.grpcPort, |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 147 | "deviceId": BMV2_DEFAULT_DEVICE_ID, |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 148 | "deviceKeyId": "p4runtime:%s" % self.onosDeviceId |
| 149 | } |
| 150 | }, |
| 151 | "piPipeconf": { |
| 152 | "piPipeconfId": self.pipeconfId |
| 153 | }, |
Andrea Campanella | bf9e5ce | 2017-12-06 14:26:36 +0100 | [diff] [blame] | 154 | "basic": basicCfg |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Carmelo Cascone | 4f985cd | 2018-02-11 17:36:42 -0800 | [diff] [blame] | 157 | if self.withGnmi: |
| 158 | cfgData["generalprovider"]["gnmi"] = { |
| 159 | "ip": srcIP, |
| 160 | "port": self.grpcPort |
| 161 | } |
| 162 | |
| 163 | if self.injectPorts: |
Andrea Campanella | bf9e5ce | 2017-12-06 14:26:36 +0100 | [diff] [blame] | 164 | portData = {} |
| 165 | portId = 1 |
| 166 | for intfName in self.intfNames(): |
| 167 | if intfName == 'lo': |
| 168 | continue |
| 169 | portData[str(portId)] = { |
| 170 | "number": portId, |
| 171 | "name": intfName, |
| 172 | "enabled": True, |
| 173 | "removed": False, |
| 174 | "type": "copper", |
| 175 | "speed": 10000 |
| 176 | } |
| 177 | portId += 1 |
| 178 | |
| 179 | cfgData['ports'] = portData |
| 180 | |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 181 | return cfgData |
| 182 | |
| 183 | def doOnosNetcfg(self, controllerIP): |
| 184 | """ |
| 185 | Notifies ONOS about the new device via Netcfg. |
| 186 | """ |
| 187 | srcIP = self.getSourceIp(controllerIP) |
| 188 | if not srcIP: |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 189 | warn("*** WARN: unable to get switch IP address, won't do netcfg\n") |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 190 | return |
| 191 | |
Carmelo Cascone | a11279b | 2017-06-22 04:30:08 -0400 | [diff] [blame] | 192 | cfgData = { |
| 193 | "devices": { |
Yi Tseng | 7875cb7 | 2017-08-08 10:15:58 -0700 | [diff] [blame] | 194 | self.onosDeviceId: self.getDeviceConfig(srcIP) |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 195 | } |
Carmelo Cascone | a11279b | 2017-06-22 04:30:08 -0400 | [diff] [blame] | 196 | } |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 197 | with open(self.netcfgfile, 'w') as fp: |
| 198 | json.dump(cfgData, fp, indent=4) |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 199 | |
| 200 | if not self.netcfg: |
| 201 | # Do not push config to ONOS. |
| 202 | return |
| 203 | |
Brian O'Connor | 71167f9 | 2017-06-16 14:55:00 -0700 | [diff] [blame] | 204 | # Build netcfg URL |
| 205 | url = 'http://%s:8181/onos/v1/network/configuration/' % controllerIP |
| 206 | # Instantiate password manager for HTTP auth |
| 207 | pm = urllib2.HTTPPasswordMgrWithDefaultRealm() |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 208 | pm.add_password(None, url, |
| 209 | os.environ['ONOS_WEB_USER'], |
| 210 | os.environ['ONOS_WEB_PASS']) |
| 211 | urllib2.install_opener(urllib2.build_opener( |
| 212 | urllib2.HTTPBasicAuthHandler(pm))) |
Brian O'Connor | 71167f9 | 2017-06-16 14:55:00 -0700 | [diff] [blame] | 213 | # Push config data to controller |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 214 | req = urllib2.Request(url, json.dumps(cfgData), |
| 215 | {'Content-Type': 'application/json'}) |
Carmelo Cascone | a11279b | 2017-06-22 04:30:08 -0400 | [diff] [blame] | 216 | try: |
| 217 | f = urllib2.urlopen(req) |
| 218 | print f.read() |
| 219 | f.close() |
| 220 | except urllib2.URLError as e: |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 221 | warn("*** WARN: unable to push config to ONOS (%s)\n" % e.reason) |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 222 | |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 223 | def start(self, controllers): |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 224 | bmv2Args = [SIMPLE_SWITCH_GRPC] + self.grpcTargetArgs() |
| 225 | if self.valgrind: |
| 226 | bmv2Args = VALGRIND_PREFIX.split() + bmv2Args |
| 227 | |
| 228 | cmdString = " ".join(bmv2Args) |
| 229 | |
| 230 | if self.dryrun: |
| 231 | info("\n*** DRY RUN (not executing bmv2)") |
| 232 | |
| 233 | info("\nStarting BMv2 target: %s\n" % cmdString) |
| 234 | |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 235 | writeToFile("/tmp/bmv2-%s-grpc-port" % self.name, self.grpcPort) |
| 236 | writeToFile("/tmp/bmv2-%s-thrift-port" % self.name, self.thriftPort) |
| 237 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 238 | try: |
| 239 | if not self.dryrun: |
| 240 | # Start the switch |
| 241 | self.logfd = open(self.logfile, "w") |
| 242 | self.bmv2popen = self.popen(cmdString, |
| 243 | stdout=self.logfd, |
| 244 | stderr=self.logfd) |
| 245 | self.waitBmv2Start() |
| 246 | # We want to be notified if BMv2 dies... |
| 247 | threading.Thread(target=watchDog, args=[self]).start() |
| 248 | |
| 249 | self.doOnosNetcfg(self.controllerIp(controllers)) |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 250 | except Exception: |
| 251 | ONOSBmv2Switch.mininet_exception = 1 |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 252 | self.killBmv2() |
| 253 | self.printBmv2Log() |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 254 | raise |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 255 | |
| 256 | def grpcTargetArgs(self): |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 257 | if self.grpcPort is None: |
| 258 | self.grpcPort = pickUnusedPort() |
| 259 | if self.thriftPort is None: |
| 260 | self.thriftPort = pickUnusedPort() |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 261 | args = ['--device-id %s' % str(BMV2_DEFAULT_DEVICE_ID)] |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 262 | for port, intf in self.intfs.items(): |
| 263 | if not intf.IP(): |
| 264 | args.append('-i %d@%s' % (port, intf.name)) |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 265 | args.append('--thrift-port %s' % self.thriftPort) |
| 266 | ntfaddr = 'ipc:///tmp/bmv2-%s-notifications.ipc' % self.name |
| 267 | args.append('--notifications-addr %s' % ntfaddr) |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 268 | if self.elogger: |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 269 | nanologaddr = 'ipc:///tmp/bmv2-%s-nanolog.ipc' % self.name |
| 270 | args.append('--nanolog %s' % nanologaddr) |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 271 | if self.debugger: |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 272 | dbgaddr = 'ipc:///tmp/bmv2-%s-debug.ipc' % self.name |
| 273 | args.append('--debugger-addr %s' % dbgaddr) |
Carmelo Cascone | fb76b04 | 2017-07-17 19:42:00 -0400 | [diff] [blame] | 274 | args.append('--log-console') |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 275 | if self.pktdump: |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 276 | args.append('--pcap --dump-packet-data %s' % PKT_BYTES_TO_DUMP) |
Carmelo Cascone | 9e6621f | 2017-06-27 16:06:33 -0400 | [diff] [blame] | 277 | args.append('-L%s' % self.loglevel) |
Carmelo Cascone | fb76b04 | 2017-07-17 19:42:00 -0400 | [diff] [blame] | 278 | if not self.json: |
| 279 | args.append('--no-p4') |
| 280 | else: |
| 281 | args.append(self.json) |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 282 | # gRPC target-specific options |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 283 | args.append('--') |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 284 | args.append('--cpu-port %s' % self.cpuPort) |
| 285 | args.append('--grpc-server-addr 0.0.0.0:%s' % self.grpcPort) |
| 286 | return args |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 287 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 288 | def waitBmv2Start(self): |
| 289 | # Wait for switch to open gRPC port, before sending ONOS the netcfg. |
| 290 | # Include time-out just in case something hangs. |
| 291 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| 292 | endtime = time.time() + SWITCH_START_TIMEOUT |
| 293 | while True: |
| 294 | result = sock.connect_ex(('127.0.0.1', self.grpcPort)) |
| 295 | if result == 0: |
| 296 | # The port is open. Let's go! (Close socket first) |
| 297 | sock.close() |
| 298 | break |
| 299 | # Port is not open yet. If there is time, we wait a bit. |
| 300 | if endtime > time.time(): |
Carmelo Cascone | 3c216fa | 2018-06-22 14:52:15 +0200 | [diff] [blame] | 301 | time.sleep(0.1) |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 302 | else: |
| 303 | # Time's up. |
| 304 | raise Exception("Switch did not start before timeout") |
Carmelo Cascone | fb76b04 | 2017-07-17 19:42:00 -0400 | [diff] [blame] | 305 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 306 | def printBmv2Log(self): |
| 307 | if os.path.isfile(self.logfile): |
| 308 | print "-" * 80 |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 309 | print "%s log (from %s):" % (self.name, self.logfile) |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 310 | with open(self.logfile, 'r') as f: |
| 311 | lines = f.readlines() |
| 312 | if len(lines) > BMV2_LOG_LINES: |
| 313 | print "..." |
| 314 | for line in lines[-BMV2_LOG_LINES:]: |
| 315 | print line.rstrip() |
Carmelo Cascone | fb76b04 | 2017-07-17 19:42:00 -0400 | [diff] [blame] | 316 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 317 | @staticmethod |
| 318 | def controllerIp(controllers): |
| 319 | try: |
| 320 | # onos.py |
Carmelo Cascone | 46d360b | 2017-08-29 20:20:32 +0200 | [diff] [blame] | 321 | clist = controllers[0].nodes() |
| 322 | except AttributeError: |
| 323 | clist = controllers |
| 324 | assert len(clist) > 0 |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 325 | return clist[0].IP() |
Keesjan Karsten | 8539f08 | 2018-01-04 17:03:31 +0100 | [diff] [blame] | 326 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 327 | def killBmv2(self, log=False): |
| 328 | if self.bmv2popen is not None: |
| 329 | self.bmv2popen.kill() |
| 330 | if self.logfd is not None: |
| 331 | if log: |
| 332 | self.logfd.write("*** PROCESS TERMINATED BY MININET ***\n") |
| 333 | self.logfd.close() |
Keesjan Karsten | 8539f08 | 2018-01-04 17:03:31 +0100 | [diff] [blame] | 334 | |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 335 | def cleanupTmpFiles(self): |
Carmelo Cascone | c282133 | 2018-05-14 18:15:33 -0700 | [diff] [blame] | 336 | self.cmd("rm -f /tmp/bmv2-%s-*" % self.name) |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 337 | |
| 338 | def stop(self, deleteIntfs=True): |
| 339 | """Terminate switch.""" |
Carmelo Cascone | f11513d | 2018-01-16 00:31:14 -0800 | [diff] [blame] | 340 | self.stopped = True |
| 341 | self.killBmv2(log=True) |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 342 | Switch.stop(self, deleteIntfs) |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 343 | |
| 344 | |
Carmelo Cascone | b752427 | 2017-06-05 16:53:13 -0400 | [diff] [blame] | 345 | # Exports for bin/mn |
Carmelo Cascone | 785fada | 2016-06-16 18:34:16 -0700 | [diff] [blame] | 346 | switches = {'onosbmv2': ONOSBmv2Switch} |
Carmelo Cascone | 3443325 | 2017-08-25 20:27:18 +0200 | [diff] [blame] | 347 | hosts = {'onoshost': ONOSHost} |