VNFs/DPPD-PROX/helper-scripts/dpi/prox.py

   1 #!/bin/env python
   2
   3 ##
   4 ## Copyright (c) 2010-2017 Intel Corporation
   5 ##
   6 ## Licensed under the Apache License, Version 2.0 (the "License");
   7 ## you may not use this file except in compliance with the License.
   8 ## You may obtain a copy of the License at
   9 ##
  10 ##     http://www.apache.org/licenses/LICENSE-2.0
  11 ##
  12 ## Unless required by applicable law or agreed to in writing, software
  13 ## distributed under the License is distributed on an "AS IS" BASIS,
  14 ## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 ## See the License for the specific language governing permissions and
  16 ## limitations under the License.
  17 ##
  18
  19 import threading
  20 from time import *
  21 from proxsocket import *
  22 from remotesystem import *
  23
  24 class ProxStarter:
  25     def __init__(self, remoteSystem, cmd):
  26         self._remoteSystem = remoteSystem
  27         self._cmd = cmd
  28         self._thread = None
  29         self._prox = None;
  30         self._result = None;
  31         self._startDuration = None
  32
  33     def startThreaded(self):
  34         self._start_thread = threading.Thread(target = self._run, args = (self, 1))
  35         self._start_thread.start();
  36
  37     def joinThreaded(self):
  38         self._start_thread.join();
  39         return self._result;
  40
  41     def getResult(self):
  42         return self._result;
  43
  44     def getStartDuration(self):
  45         return self._startDuration;
  46     def getProx(self):
  47         return self._prox;
  48
  49     def _run(self, a, b):
  50         before = time.time()
  51         self._remoteSystem.run("sudo killall -w -q -9 prox")
  52
  53         self._result = self._remoteSystem.run(self._cmd);
  54
  55         sleep(1)
  56         after = time.time()
  57         self._startDuration = after - before;
  58
  59 class StatsCmd(object):
  60     def __init__(self, prox):
  61         self._cmd = ""
  62         self._parts = []
  63         self._beforeParts = []
  64         self._prox = prox;
  65
  66     def sendRecv(self):
  67         cmd = self.getCmd()
  68         reply = self._prox._send(cmd)._recv()
  69         self.setReply(reply)
  70
  71     def add(self, stats):
  72         if (len(self._cmd) != 0):
  73             self._cmd += ","
  74         self._cmd += stats
  75
  76         if (len(self._parts) == 0):
  77             self._beforeParts += [0]
  78         else:
  79             before = self._parts[-1] + self._beforeParts[-1];
  80             self._beforeParts += [before]
  81
  82         self._parts += [stats.count(",") + 1];
  83
  84     def getCmd(self):
  85         return "stats " + self._cmd;
  86
  87     def setReply(self, reply):
  88         self._reply = reply.split(",");
  89
  90     def getResult(self, idx):
  91         start = self._beforeParts[idx];
  92         end = start + self._parts[idx];
  93         return self._reply[start:end]
  94
  95 class Prox(object):
  96     def __init__(self, systemConfig):
  97         self._systemConfig = systemConfig;
  98         self._proxStarter = None
  99
 100         user = self._systemConfig._user
 101         ip = self._systemConfig._ip
 102         self._remoteSystem = remoteSystem(user, ip);
 103
 104         self.resetArguments()
 105
 106     def resetArguments(self):
 107         self._args = []
 108
 109     def addArgument(self, arg):
 110         self._args.append(arg);
 111
 112     def startFork(self):
 113         cmd = self.getCmd();
 114         self._proxStarter = ProxStarter(self._remoteSystem, cmd)
 115         self._proxStarter.startThreaded();
 116
 117     def startJoin(self):
 118         ret = self.startJoinNoConnect();
 119         self._connectSocket();
 120         self._querySetup();
 121         return self._proxStarter.getStartDuration();
 122
 123     def startJoinNoConnect(self):
 124         return self._proxStarter.joinThreaded();
 125
 126     def getCmd(self):
 127         proxDir = self._systemConfig.getProxDir();
 128         cfgFile = self._systemConfig.getCfgFile();
 129
 130         cmd = "cd " + proxDir + "; "
 131         cmd += "sudo ./build/prox "
 132         cmd += "-f " + cfgFile
 133
 134         for arg in self._args:
 135             cmd += " " + arg
 136         return cmd
 137
 138     def getLog(self):
 139         proxDir = self._systemConfig.getProxDir()
 140         cmd = "cat " + proxDir + "/prox.log";
 141         return self._remoteSystem.run(cmd)["out"];
 142
 143     def getIP(self):
 144         return self._systemConfig._ip;
 145
 146     def getHz(self):
 147         return self._hz;
 148
 149     def getBeg(self):
 150         return self._beg;
 151
 152     def getPorts(self):
 153         return self._ports;
 154
 155     def getIerrors(self):
 156         sc = StatsCmd(self)
 157         sc.add(self._buildIerrorsCmd());
 158         sc.sendRecv()
 159         return self._parseIerrorsReply(sc.getResult(0));
 160
 161     def _parseIerrorsReply(self, rep):
 162         tot_ierrors = 0;
 163         for e in rep:
 164             tot_ierrors += int(e);
 165         return tot_ierrors;
 166
 167     def _buildIerrorsCmd(self):
 168         cmd = ""
 169         for port in self._ports:
 170             if (len(cmd)):
 171                 cmd += ","
 172             cmd += "port(%s).ierrors" % str(port)
 173         return cmd;
 174
 175     def waitCmdFinished(self):
 176         self._send("stats hz")._recv();
 177
 178     def waitAllLinksUp(self):
 179         link_down = True;
 180         while (link_down):
 181             link_down = False;
 182             for port in self._ports:
 183                 cmd = "port link state %s" % str(port)
 184                 link_state = self._send(cmd)._recv();
 185                 if (link_state == "down"):
 186                     link_down = True;
 187                     print "Link down on port " + str(port) + ", waiting one second"
 188                     break;
 189             sleep(1);
 190
 191     def startAllCores(self):
 192         self._send("start all");
 193
 194     def stopAllCores(self):
 195         self._send("stop all");
 196
 197     def forceQuit(self):
 198         self._send("quit_force")._recv();
 199
 200     def killProx(self):
 201         self._remoteSystem.run("sudo killall -w -q -9 prox")
 202
 203     def getTsc(self):
 204         return self._getTsc();
 205
 206     def _getTsc(self):
 207         return int(self._send("stats global.tsc")._recv());
 208
 209     def scpStatsDump(self, dst):
 210         proxDir = self._systemConfig.getProxDir()
 211
 212         src = proxDir + "/stats_dump";
 213         print "Copying " + src + " to " + dst
 214         self._remoteSystem.scp(src, dst);
 215
 216     def _querySetup(self):
 217         print "Query setup on " + str(self.getIP())
 218         self._queryHz()
 219         self._queryBeg()
 220         self._queryPorts()
 221         self._querySetup2()
 222
 223     def _querySetup2(self):
 224         print "running query 2"
 225         pass
 226
 227     def quitProx(self):
 228         self._send("quit")._recv();
 229
 230     def _queryHz(self):
 231         self._hz = int(self._send("stats hz")._recv());
 232
 233     def _queryBeg(self):
 234         self._beg = self._getTsc();
 235
 236     def _queryPorts(self):
 237         self._ports = []
 238         port_info_all = self._send("port info all")._recv();
 239         port_info_list = port_info_all.split(',');
 240
 241         for port_info in port_info_list:
 242             if (len(port_info) > 0):
 243                 self._ports.append(int(port_info.split(":")[0]));
 244
 245     def _connectSocket(self):
 246         self._proxSocket = ProxSocket(self.getIP())
 247
 248     def _send(self, msg):
 249         self._proxSocket.send(msg);
 250         return self
 251
 252     def _recv(self):
 253         return self._proxSocket.recv();