aboutsummaryrefslogtreecommitdiffstats
path: root/src/scripts
diff options
context:
space:
mode:
Diffstat (limited to 'src/scripts')
-rwxr-xr-xsrc/scripts/fts.py215
-rwxr-xr-xsrc/scripts/host-stack/cc_plots.py336
-rwxr-xr-xsrc/scripts/vnet/uri/dummy_app.py110
3 files changed, 378 insertions, 283 deletions
diff --git a/src/scripts/fts.py b/src/scripts/fts.py
index f2b877fb2c7..e8ff477c788 100755
--- a/src/scripts/fts.py
+++ b/src/scripts/fts.py
@@ -21,25 +21,28 @@ schema = {
"name": {"type": "string"},
"description": {"type": "string"},
"maintainer": {"$ref": "#/definitions/maintainers"},
- "state": {"type": "string",
- "enum": ["production", "experimental", "development"]},
+ "state": {
+ "type": "string",
+ "enum": ["production", "experimental", "development"],
+ },
"features": {"$ref": "#/definitions/features"},
"missing": {"$ref": "#/definitions/features"},
- "properties": {"type": "array",
- "items": {"type": "string",
- "enum": ["API", "CLI", "STATS",
- "MULTITHREAD"]},
- },
+ "properties": {
+ "type": "array",
+ "items": {"type": "string", "enum": ["API", "CLI", "STATS", "MULTITHREAD"]},
+ },
},
"additionalProperties": False,
"definitions": {
"maintainers": {
- "anyof": [{
- "type": "array",
- "items": {"type": "string"},
- "minItems": 1,
- },
- {"type": "string"}],
+ "anyof": [
+ {
+ "type": "array",
+ "items": {"type": "string"},
+ "minItems": 1,
+ },
+ {"type": "string"},
+ ],
},
"featureobject": {
"type": "object",
@@ -49,9 +52,12 @@ schema = {
},
"features": {
"type": "array",
- "items": {"anyOf": [{"$ref": "#/definitions/featureobject"},
- {"type": "string"},
- ]},
+ "items": {
+ "anyOf": [
+ {"$ref": "#/definitions/featureobject"},
+ {"type": "string"},
+ ]
+ },
"minItems": 1,
},
},
@@ -59,14 +65,15 @@ schema = {
DEFAULT_REPO_LINK = "https://github.com/FDio/vpp/blob/master/"
+
def filelist_from_git_status():
filelist = []
- git_status = 'git status --porcelain */FEATURE*.yaml'
+ git_status = "git status --porcelain */FEATURE*.yaml"
rv = run(git_status.split(), stdout=PIPE, stderr=PIPE)
if rv.returncode != 0:
sys.exit(rv.returncode)
- for l in rv.stdout.decode('ascii').split('\n'):
+ for l in rv.stdout.decode("ascii").split("\n"):
if len(l):
filelist.append(l.split()[1])
return filelist
@@ -74,24 +81,26 @@ def filelist_from_git_status():
def filelist_from_git_ls():
filelist = []
- git_ls = 'git ls-files :(top)*/FEATURE*.yaml'
+ git_ls = "git ls-files :(top)*/FEATURE*.yaml"
rv = run(git_ls.split(), stdout=PIPE, stderr=PIPE)
if rv.returncode != 0:
sys.exit(rv.returncode)
- for l in rv.stdout.decode('ascii').split('\n'):
+ for l in rv.stdout.decode("ascii").split("\n"):
if len(l):
filelist.append(l)
return filelist
+
def version_from_git():
- git_describe = 'git describe'
+ git_describe = "git describe"
rv = run(git_describe.split(), stdout=PIPE, stderr=PIPE)
if rv.returncode != 0:
sys.exit(rv.returncode)
- return rv.stdout.decode('ascii').split('\n')[0]
+ return rv.stdout.decode("ascii").split("\n")[0]
+
-class MarkDown():
+class MarkDown:
_dispatch = {}
def __init__(self, stream):
@@ -101,102 +110,115 @@ class MarkDown():
def print_maintainer(self, o):
write = self.stream.write
if type(o) is list:
- write('Maintainers: ' +
- ', '.join('{m}'.format(m=m) for m in
- o) + ' \n')
+ write("Maintainers: " + ", ".join("{m}".format(m=m) for m in o) + " \n")
else:
- write('Maintainer: {o} \n'.format(o=o))
+ write("Maintainer: {o} \n".format(o=o))
- _dispatch['maintainer'] = print_maintainer
+ _dispatch["maintainer"] = print_maintainer
def print_features(self, o, indent=0):
write = self.stream.write
for f in o:
- indentstr = ' ' * indent
+ indentstr = " " * indent
if type(f) is dict:
for k, v in f.items():
- write('{indentstr}- {k}\n'.format(indentstr=indentstr, k=k))
+ write("{indentstr}- {k}\n".format(indentstr=indentstr, k=k))
self.print_features(v, indent + 2)
else:
- write('{indentstr}- {f}\n'.format(indentstr=indentstr, f=f))
- write('\n')
- _dispatch['features'] = print_features
+ write("{indentstr}- {f}\n".format(indentstr=indentstr, f=f))
+ write("\n")
+
+ _dispatch["features"] = print_features
def print_markdown_header(self, o):
write = self.stream.write
- write('## {o}\n'.format(o=o))
- _dispatch['markdown_header'] = print_markdown_header
+ write("## {o}\n".format(o=o))
+
+ _dispatch["markdown_header"] = print_markdown_header
def print_name(self, o):
write = self.stream.write
- write('### {o}\n'.format(o=o))
+ write("### {o}\n".format(o=o))
self.toc.append(o)
- _dispatch['name'] = print_name
+
+ _dispatch["name"] = print_name
def print_description(self, o):
write = self.stream.write
- write('\n{o}\n\n'.format(o=o))
- _dispatch['description'] = print_description
+ write("\n{o}\n\n".format(o=o))
+
+ _dispatch["description"] = print_description
def print_state(self, o):
write = self.stream.write
- write('Feature maturity level: {o} \n'.format(o=o))
- _dispatch['state'] = print_state
+ write("Feature maturity level: {o} \n".format(o=o))
+
+ _dispatch["state"] = print_state
def print_properties(self, o):
write = self.stream.write
- write('Supports: {s} \n'.format(s=" ".join(o)))
- _dispatch['properties'] = print_properties
+ write("Supports: {s} \n".format(s=" ".join(o)))
+
+ _dispatch["properties"] = print_properties
def print_missing(self, o):
write = self.stream.write
- write('\nNot yet implemented: \n')
+ write("\nNot yet implemented: \n")
self.print_features(o)
- _dispatch['missing'] = print_missing
+
+ _dispatch["missing"] = print_missing
def print_code(self, o):
write = self.stream.write
- write('Source Code: [{o}]({o}) \n'.format(o=o))
- _dispatch['code'] = print_code
+ write("Source Code: [{o}]({o}) \n".format(o=o))
+
+ _dispatch["code"] = print_code
def print(self, t, o):
write = self.stream.write
if t in self._dispatch:
- self._dispatch[t](self, o,)
+ self._dispatch[t](
+ self,
+ o,
+ )
else:
- write('NOT IMPLEMENTED: {t}\n')
+ write("NOT IMPLEMENTED: {t}\n")
+
def output_toc(toc, stream):
write = stream.write
- write('# VPP Supported Features\n')
+ write("# VPP Supported Features\n")
for t in toc:
- ref = t.lower().replace(' ', '-')
- write('[{t}](#{ref}) \n'.format(t=t, ref=ref))
+ ref = t.lower().replace(" ", "-")
+ write("[{t}](#{ref}) \n".format(t=t, ref=ref))
+
def featuresort(k):
- return k[1]['name']
+ return k[1]["name"]
+
def featurelistsort(k):
orderedfields = {
- 'name': 0,
- 'maintainer': 1,
- 'description': 2,
- 'features': 3,
- 'state': 4,
- 'properties': 5,
- 'missing': 6,
- 'code': 7,
+ "name": 0,
+ "maintainer": 1,
+ "description": 2,
+ "features": 3,
+ "state": 4,
+ "properties": 5,
+ "missing": 6,
+ "code": 7,
}
return orderedfields[k[0]]
+
def output_markdown(features, fields, notfields, repository_url):
stream = StringIO()
m = MarkDown(stream)
- m.print('markdown_header', 'Feature Details:')
+ m.print("markdown_header", "Feature Details:")
for path, featuredef in sorted(features.items(), key=featuresort):
codeurl = urllib.parse.urljoin(repository_url, os.path.dirname(path))
- featuredef['code'] = codeurl
+ featuredef["code"] = codeurl
for k, v in sorted(featuredef.items(), key=featurelistsort):
if notfields:
if k not in notfields:
@@ -211,24 +233,45 @@ def output_markdown(features, fields, notfields, repository_url):
output_toc(m.toc, tocstream)
return tocstream, stream
+
def main():
- parser = argparse.ArgumentParser(description='VPP Feature List.')
- parser.add_argument('--validate', dest='validate', action='store_true',
- help='validate the FEATURE.yaml file')
- parser.add_argument("--repolink", metavar="repolink", default=DEFAULT_REPO_LINK,
- help="Link to public repository [%s]" %
- DEFAULT_REPO_LINK)
- parser.add_argument('--git-status', dest='git_status', action='store_true',
- help='Get filelist from git status')
- parser.add_argument('--all', dest='all', action='store_true',
- help='Validate all files in repository')
- parser.add_argument('--markdown', dest='markdown', action='store_true',
- help='Output feature table in markdown')
- parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
- default=sys.stdin)
+ parser = argparse.ArgumentParser(description="VPP Feature List.")
+ parser.add_argument(
+ "--validate",
+ dest="validate",
+ action="store_true",
+ help="validate the FEATURE.yaml file",
+ )
+ parser.add_argument(
+ "--repolink",
+ metavar="repolink",
+ default=DEFAULT_REPO_LINK,
+ help="Link to public repository [%s]" % DEFAULT_REPO_LINK,
+ )
+ parser.add_argument(
+ "--git-status",
+ dest="git_status",
+ action="store_true",
+ help="Get filelist from git status",
+ )
+ parser.add_argument(
+ "--all",
+ dest="all",
+ action="store_true",
+ help="Validate all files in repository",
+ )
+ parser.add_argument(
+ "--markdown",
+ dest="markdown",
+ action="store_true",
+ help="Output feature table in markdown",
+ )
+ parser.add_argument(
+ "infile", nargs="?", type=argparse.FileType("r"), default=sys.stdin
+ )
group = parser.add_mutually_exclusive_group()
- group.add_argument('--include', help='List of fields to include')
- group.add_argument('--exclude', help='List of fields to exclude')
+ group.add_argument("--include", help="List of fields to include")
+ group.add_argument("--exclude", help="List of fields to exclude")
args = parser.parse_args()
features = {}
@@ -240,11 +283,11 @@ def main():
filelist = args.infile
if args.include:
- fields = args.include.split(',')
+ fields = args.include.split(",")
else:
fields = []
if args.exclude:
- notfields = args.exclude.split(',')
+ notfields = args.exclude.split(",")
else:
notfields = []
@@ -252,13 +295,15 @@ def main():
featurefile = featurefile.rstrip()
# Load configuration file
- with open(featurefile, encoding='utf-8') as f:
+ with open(featurefile, encoding="utf-8") as f:
cfg = yaml.load(f, Loader=yaml.SafeLoader)
try:
validate(instance=cfg, schema=schema)
except exceptions.ValidationError:
- print('File does not validate: {featurefile}' \
- .format(featurefile=featurefile), file=sys.stderr)
+ print(
+ "File does not validate: {featurefile}".format(featurefile=featurefile),
+ file=sys.stderr,
+ )
raise
features[featurefile] = cfg
@@ -270,5 +315,5 @@ def main():
stream.close()
-if __name__ == '__main__':
+if __name__ == "__main__":
main()
diff --git a/src/scripts/host-stack/cc_plots.py b/src/scripts/host-stack/cc_plots.py
index 20f5bd6a3f1..f0296af7223 100755
--- a/src/scripts/host-stack/cc_plots.py
+++ b/src/scripts/host-stack/cc_plots.py
@@ -6,214 +6,242 @@ import argparse
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
-class Point():
+
+class Point:
"CC event"
+
def __init__(self, x, y):
self.x = x
self.y = y
+
def listx(points):
- return list(map(lambda pt: pt.x, points))
+ return list(map(lambda pt: pt.x, points))
+
def listy(points):
- return list(map(lambda pt: pt.y, points))
+ return list(map(lambda pt: pt.y, points))
+
def plot_data(d):
- plt.figure(1)
-
- cwndx = listx(d["cwnd"])
- cwndy = listy(d["cwnd"])
- congx = listx(d["congestion"])
- congy = listy(d["congestion"])
- rcvrdx = listx(d["recovered"])
- rcvrdy = listy(d["recovered"])
- rxttx = listx(d["rxtTimeout"])
- rxtty = listy(d["rxtTimeout"])
-
- # cwnd/ssthresh/cc events
- plt.subplot(311)
- plt.title("cwnd/ssthresh")
- pcwnd = plt.plot(cwndx, cwndy, 'r')
- psst = plt.plot(cwndx, d["ssthresh"], 'y-')
- pcong = plt.plot(congx, congy,'yo')
- precov = plt.plot(rcvrdx, rcvrdy,'co')
- prxtt = plt.plot(rxttx, rxtty,'mo')
-
- marker1 = Line2D(range(1), range(1), color="r")
- marker2 = Line2D(range(1), range(1), color="y")
- marker3 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="y")
- marker4 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="c")
- marker5 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="m")
- plt.legend((marker1, marker2, marker3, marker4, marker5),
- ('cwnd', 'ssthresh', 'congestion', 'recovered', 'rxt-timeout'),
- loc=4)
- axes = plt.gca()
- axes.set_ylim([-20e4, max(cwndy) + 20e4])
-
- # snd variables
- plt.subplot(312)
- plt.title("cc variables")
- plt.plot(cwndx, d["space"], 'g-', markersize=1)
- plt.plot(cwndx, d["flight"], 'b-', markersize=1)
- plt.plot(cwndx, d["sacked"], 'm:', markersize=1)
- plt.plot(cwndx, d["lost"], 'y:', markersize=1)
- plt.plot(cwndx, d["cc-space"], 'k:', markersize=1)
- plt.plot(cwndx, cwndy, 'ro', markersize=2)
-
- plt.plot(congx, congy, 'y^', markersize=10, markerfacecolor="y")
- plt.plot(rcvrdx, rcvrdy, 'c^', markersize=10, markerfacecolor="c")
- plt.plot(rxttx, rxtty, 'm^', markersize=10, markerfacecolor="m")
-
- #plt.plot(cwndx, d["snd_wnd"], 'ko', markersize=1)
- plt.legend(("snd-space", "flight", "sacked", "lost", "cc-space", "cwnd",
- "congestion", "recovered", "rxt-timeout"),
- loc=1)
-
- # rto/srrt/rttvar
- plt.subplot(313)
- plt.title("rtt")
- plt.plot(cwndx, d["srtt"], 'g-')
- plt.plot(cwndx, [x/1000 for x in d["mrtt-us"]], 'r-')
- plt.plot(cwndx, d["rttvar"], 'b-')
- plt.legend(["srtt", "mrtt-us", "rttvar"])
- axes = plt.gca()
- #plt.plot(cwndx, rto, 'r-')
- #axes.set_ylim([0, int(max(rto[2:len(rto)])) + 50])
-
- # show
- plt.show()
-
-def find_pattern(file_path,session_idx):
+ plt.figure(1)
+
+ cwndx = listx(d["cwnd"])
+ cwndy = listy(d["cwnd"])
+ congx = listx(d["congestion"])
+ congy = listy(d["congestion"])
+ rcvrdx = listx(d["recovered"])
+ rcvrdy = listy(d["recovered"])
+ rxttx = listx(d["rxtTimeout"])
+ rxtty = listy(d["rxtTimeout"])
+
+ # cwnd/ssthresh/cc events
+ plt.subplot(311)
+ plt.title("cwnd/ssthresh")
+ pcwnd = plt.plot(cwndx, cwndy, "r")
+ psst = plt.plot(cwndx, d["ssthresh"], "y-")
+ pcong = plt.plot(congx, congy, "yo")
+ precov = plt.plot(rcvrdx, rcvrdy, "co")
+ prxtt = plt.plot(rxttx, rxtty, "mo")
+
+ marker1 = Line2D(range(1), range(1), color="r")
+ marker2 = Line2D(range(1), range(1), color="y")
+ marker3 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="y")
+ marker4 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="c")
+ marker5 = Line2D(range(1), range(1), color="w", marker="o", markerfacecolor="m")
+ plt.legend(
+ (marker1, marker2, marker3, marker4, marker5),
+ ("cwnd", "ssthresh", "congestion", "recovered", "rxt-timeout"),
+ loc=4,
+ )
+ axes = plt.gca()
+ axes.set_ylim([-20e4, max(cwndy) + 20e4])
+
+ # snd variables
+ plt.subplot(312)
+ plt.title("cc variables")
+ plt.plot(cwndx, d["space"], "g-", markersize=1)
+ plt.plot(cwndx, d["flight"], "b-", markersize=1)
+ plt.plot(cwndx, d["sacked"], "m:", markersize=1)
+ plt.plot(cwndx, d["lost"], "y:", markersize=1)
+ plt.plot(cwndx, d["cc-space"], "k:", markersize=1)
+ plt.plot(cwndx, cwndy, "ro", markersize=2)
+
+ plt.plot(congx, congy, "y^", markersize=10, markerfacecolor="y")
+ plt.plot(rcvrdx, rcvrdy, "c^", markersize=10, markerfacecolor="c")
+ plt.plot(rxttx, rxtty, "m^", markersize=10, markerfacecolor="m")
+
+ # plt.plot(cwndx, d["snd_wnd"], 'ko', markersize=1)
+ plt.legend(
+ (
+ "snd-space",
+ "flight",
+ "sacked",
+ "lost",
+ "cc-space",
+ "cwnd",
+ "congestion",
+ "recovered",
+ "rxt-timeout",
+ ),
+ loc=1,
+ )
+
+ # rto/srrt/rttvar
+ plt.subplot(313)
+ plt.title("rtt")
+ plt.plot(cwndx, d["srtt"], "g-")
+ plt.plot(cwndx, [x / 1000 for x in d["mrtt-us"]], "r-")
+ plt.plot(cwndx, d["rttvar"], "b-")
+ plt.legend(["srtt", "mrtt-us", "rttvar"])
+ axes = plt.gca()
+ # plt.plot(cwndx, rto, 'r-')
+ # axes.set_ylim([0, int(max(rto[2:len(rto)])) + 50])
+
+ # show
+ plt.show()
+
+
+def find_pattern(file_path, session_idx):
is_active_open = 1
listener_pattern = "l\[\d\]"
- if (is_active_open):
- initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s+open:\s"
+ if is_active_open:
+ initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s+open:\s"
else:
- initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s"
+ initial_pattern = "\[\d\](\.\d+:\d+\->\.\d+:\d+)\s"
idx = 0
- f = open(file_path, 'r')
+ f = open(file_path, "r")
for line in f:
- # skip listener lines (server)
- if (re.search(listener_pattern, line) != None):
- continue
- match = re.search(initial_pattern, line)
- if (match == None):
- continue
- if (idx < session_idx):
- idx += 1
- continue
- filter_pattern = str(match.group(1)) + "\s+(.+)"
- print ("pattern is %s" % filter_pattern)
- f.close()
- return filter_pattern
- raise Exception ("Could not find initial pattern")
+ # skip listener lines (server)
+ if re.search(listener_pattern, line) != None:
+ continue
+ match = re.search(initial_pattern, line)
+ if match == None:
+ continue
+ if idx < session_idx:
+ idx += 1
+ continue
+ filter_pattern = str(match.group(1)) + "\s+(.+)"
+ print("pattern is %s" % filter_pattern)
+ f.close()
+ return filter_pattern
+ raise Exception("Could not find initial pattern")
+
def compute_time(min, sec, msec):
- return int(min)*60 + int(sec) + int(msec)/1000.0
+ return int(min) * 60 + int(sec) + int(msec) / 1000.0
+
def run(file_path, session_idx):
filter_sessions = 1
filter_pattern = ""
patterns = {
- "time" : "^\d+:(\d+):(\d+):(\d+):\d+",
- "listener" : "l\[\d\]",
- "cc" : "cwnd (\d+) flight (\d+) space (\d+) ssthresh (\d+) snd_wnd (\d+)",
- "cc-snd" : "cc_space (\d+) sacked (\d+) lost (\d+)",
- "rtt" : "rto (\d+) srtt (\d+) mrtt-us (\d+) rttvar (\d+)",
- "rxtt" : "rxt-timeout",
- "congestion": "congestion",
- "recovered" : "recovered",
+ "time": "^\d+:(\d+):(\d+):(\d+):\d+",
+ "listener": "l\[\d\]",
+ "cc": "cwnd (\d+) flight (\d+) space (\d+) ssthresh (\d+) snd_wnd (\d+)",
+ "cc-snd": "cc_space (\d+) sacked (\d+) lost (\d+)",
+ "rtt": "rto (\d+) srtt (\d+) mrtt-us (\d+) rttvar (\d+)",
+ "rxtt": "rxt-timeout",
+ "congestion": "congestion",
+ "recovered": "recovered",
}
d = {
- "cwnd" : [],
- "space" : [],
- "flight" : [],
- "ssthresh" : [],
- "snd_wnd" : [],
- "cc-space" : [],
- "lost" : [],
- "sacked" : [],
- "rto" : [],
- "srtt" : [],
- "mrtt-us" : [],
- "rttvar" : [],
- "rxtTimeout" : [],
- "congestion" : [],
- "recovered" : [],
+ "cwnd": [],
+ "space": [],
+ "flight": [],
+ "ssthresh": [],
+ "snd_wnd": [],
+ "cc-space": [],
+ "lost": [],
+ "sacked": [],
+ "rto": [],
+ "srtt": [],
+ "mrtt-us": [],
+ "rttvar": [],
+ "rxtTimeout": [],
+ "congestion": [],
+ "recovered": [],
}
- if (filter_sessions):
+ if filter_sessions:
filter_pattern = find_pattern(file_path, session_idx)
- f = open(file_path, 'r')
+ f = open(file_path, "r")
stats_index = 0
start_time = 0
for line in f:
# skip listener lines (server)
- if (re.search(patterns["listener"], line) != None):
+ if re.search(patterns["listener"], line) != None:
continue
# filter sessions
- if (filter_sessions):
+ if filter_sessions:
match = re.search(filter_pattern, line)
- if (match == None):
+ if match == None:
continue
original_line = line
line = match.group(1)
- match = re.search (patterns["time"], original_line)
- if (match == None):
- print "something went wrong! no time!"
- continue
- time = compute_time (match.group(1), match.group(2), match.group(3))
- if (start_time == 0):
- start_time = time
+ match = re.search(patterns["time"], original_line)
+ if match == None:
+ print("something went wrong! no time!")
+ continue
+ time = compute_time(match.group(1), match.group(2), match.group(3))
+ if start_time == 0:
+ start_time = time
time = time - start_time
match = re.search(patterns["cc"], line)
- if (match != None):
- d["cwnd"].append(Point(time, int(match.group(1))))
- d["flight"].append(int(match.group(2)))
- d["space"].append(int(match.group(3)))
- d["ssthresh"].append(int(match.group(4)))
- d["snd_wnd"].append(int(match.group(5)))
- stats_index += 1
- continue
+ if match != None:
+ d["cwnd"].append(Point(time, int(match.group(1))))
+ d["flight"].append(int(match.group(2)))
+ d["space"].append(int(match.group(3)))
+ d["ssthresh"].append(int(match.group(4)))
+ d["snd_wnd"].append(int(match.group(5)))
+ stats_index += 1
+ continue
match = re.search(patterns["cc-snd"], line)
- if (match != None):
- d["cc-space"].append(int(match.group(1)))
- d["sacked"].append(int(match.group(2)))
- d["lost"].append(int(match.group(3)))
+ if match != None:
+ d["cc-space"].append(int(match.group(1)))
+ d["sacked"].append(int(match.group(2)))
+ d["lost"].append(int(match.group(3)))
match = re.search(patterns["rtt"], line)
- if (match != None):
- d["rto"].append(int(match.group(1)))
- d["srtt"].append(int(match.group(2)))
- d["mrtt-us"].append(int(match.group(3)))
- d["rttvar"].append(int(match.group(4)))
- if (stats_index == 0):
- continue
+ if match != None:
+ d["rto"].append(int(match.group(1)))
+ d["srtt"].append(int(match.group(2)))
+ d["mrtt-us"].append(int(match.group(3)))
+ d["rttvar"].append(int(match.group(4)))
+ if stats_index == 0:
+ continue
match = re.search(patterns["rxtt"], line)
- if (match != None):
- d["rxtTimeout"].append(Point(time, d["cwnd"][stats_index - 1].y + 1e4))
- continue
+ if match != None:
+ d["rxtTimeout"].append(Point(time, d["cwnd"][stats_index - 1].y + 1e4))
+ continue
match = re.search(patterns["congestion"], line)
- if (match != None):
- d["congestion"].append(Point(time, d["cwnd"][stats_index - 1].y - 1e4))
- continue
+ if match != None:
+ d["congestion"].append(Point(time, d["cwnd"][stats_index - 1].y - 1e4))
+ continue
match = re.search(patterns["recovered"], line)
- if (match != None):
- d["recovered"].append(Point(time, d["cwnd"][stats_index - 1].y))
- continue
+ if match != None:
+ d["recovered"].append(Point(time, d["cwnd"][stats_index - 1].y))
+ continue
plot_data(d)
+
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Plot tcp cc logs")
- parser.add_argument('-f', action='store', dest='file', required=True,
- help="elog file in txt format")
- parser.add_argument('-s', action='store', dest='session_index', default=0,
- help="session index for which to plot cc logs" )
+ parser.add_argument(
+ "-f", action="store", dest="file", required=True, help="elog file in txt format"
+ )
+ parser.add_argument(
+ "-s",
+ action="store",
+ dest="session_index",
+ default=0,
+ help="session index for which to plot cc logs",
+ )
results = parser.parse_args()
run(results.file, int(results.session_index))
diff --git a/src/scripts/vnet/uri/dummy_app.py b/src/scripts/vnet/uri/dummy_app.py
index d96a378a193..7fab2d766ad 100755
--- a/src/scripts/vnet/uri/dummy_app.py
+++ b/src/scripts/vnet/uri/dummy_app.py
@@ -5,34 +5,41 @@ import sys
import time
import argparse
-# action can be reflect or drop
+# action can be reflect or drop
action = "drop"
test = 0
-def test_data (data, n_rcvd):
- n_read = len (data);
+
+def test_data(data, n_rcvd):
+ n_read = len(data)
for i in range(n_read):
- expected = (n_rcvd + i) & 0xff
- byte_got = ord (data[i])
- if (byte_got != expected):
- print("Difference at byte {}. Expected {} got {}"
- .format(n_rcvd + i, expected, byte_got))
+ expected = (n_rcvd + i) & 0xFF
+ byte_got = ord(data[i])
+ if byte_got != expected:
+ print(
+ "Difference at byte {}. Expected {} got {}".format(
+ n_rcvd + i, expected, byte_got
+ )
+ )
return n_read
-def handle_connection (connection, client_address):
+
+def handle_connection(connection, client_address):
print("Received connection from {}".format(repr(client_address)))
n_rcvd = 0
try:
while True:
data = connection.recv(4096)
if not data:
- break;
- if (test == 1):
- n_rcvd += test_data (data, n_rcvd)
- if (action != "drop"):
+ break
+ if test == 1:
+ n_rcvd += test_data(data, n_rcvd)
+ if action != "drop":
connection.sendall(data)
finally:
connection.close()
+
+
def run_tcp_server(ip, port):
print("Starting TCP server {}:{}".format(repr(ip), repr(port)))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -42,7 +49,9 @@ def run_tcp_server(ip, port):
sock.listen(1)
while True:
connection, client_address = sock.accept()
- handle_connection (connection, client_address)
+ handle_connection(connection, client_address)
+
+
def run_udp_server(ip, port):
print("Starting UDP server {}:{}".format(repr(ip), repr(port)))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -51,22 +60,25 @@ def run_udp_server(ip, port):
sock.bind(server_address)
while True:
data, addr = sock.recvfrom(4096)
- if (action != "drop"):
- #snd_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- sock.sendto (data, addr)
+ if action != "drop":
+ # snd_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ sock.sendto(data, addr)
+
def run_server(ip, port, proto):
- if (proto == "tcp"):
+ if proto == "tcp":
run_tcp_server(ip, port)
- elif (proto == "udp"):
+ elif proto == "udp":
run_udp_server(ip, port)
+
def prepare_data(power):
buf = []
- for i in range (0, pow(2, power)):
- buf.append(i & 0xff)
+ for i in range(0, pow(2, power)):
+ buf.append(i & 0xFF)
return bytearray(buf)
+
def run_tcp_client(ip, port):
print("Starting TCP client {}:{}".format(repr(ip), repr(port)))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -75,28 +87,33 @@ def run_tcp_client(ip, port):
data = prepare_data(16)
n_rcvd = 0
- n_sent = len (data)
+ n_sent = len(data)
try:
sock.sendall(data)
timeout = time.time() + 2
while n_rcvd < n_sent and time.time() < timeout:
tmp = sock.recv(1500)
- tmp = bytearray (tmp)
+ tmp = bytearray(tmp)
n_read = len(tmp)
for i in range(n_read):
- if (data[n_rcvd + i] != tmp[i]):
- print("Difference at byte {}. Sent {} got {}"
- .format(n_rcvd + i, data[n_rcvd + i], tmp[i]))
+ if data[n_rcvd + i] != tmp[i]:
+ print(
+ "Difference at byte {}. Sent {} got {}".format(
+ n_rcvd + i, data[n_rcvd + i], tmp[i]
+ )
+ )
n_rcvd += n_read
- if (n_rcvd < n_sent or n_rcvd > n_sent):
+ if n_rcvd < n_sent or n_rcvd > n_sent:
print("Sent {} and got back {}".format(n_sent, n_rcvd))
else:
- print("Got back what we've sent!!");
+ print("Got back what we've sent!!")
finally:
sock.close()
+
+
def run_udp_client(ip, port):
print("Starting UDP client {}:{}".format(repr(ip), repr(port)))
n_packets = 100
@@ -104,38 +121,43 @@ def run_udp_client(ip, port):
server_address = (ip, int(port))
data = prepare_data(10)
try:
- for i in range (0, n_packets):
+ for i in range(0, n_packets):
sock.sendto(data, server_address)
finally:
sock.close()
+
+
def run_client(ip, port, proto):
- if (proto == "tcp"):
+ if proto == "tcp":
run_tcp_client(ip, port)
- elif (proto == "udp"):
+ elif proto == "udp":
run_udp_client(ip, port)
+
+
def run(mode, ip, port, proto):
- if (mode == "server"):
- run_server (ip, port, proto)
- elif (mode == "client"):
- run_client (ip, port, proto)
+ if mode == "server":
+ run_server(ip, port, proto)
+ elif mode == "client":
+ run_client(ip, port, proto)
else:
raise Exception("Unknown mode. Only client and server supported")
+
if __name__ == "__main__":
parser = argparse.ArgumentParser()
- parser.add_argument('-m', action='store', dest='mode')
- parser.add_argument('-i', action='store', dest='ip')
- parser.add_argument('-p', action='store', dest='port')
- parser.add_argument('-proto', action='store', dest='proto')
- parser.add_argument('-a', action='store', dest='action')
- parser.add_argument('-t', action='store', dest='test')
+ parser.add_argument("-m", action="store", dest="mode")
+ parser.add_argument("-i", action="store", dest="ip")
+ parser.add_argument("-p", action="store", dest="port")
+ parser.add_argument("-proto", action="store", dest="proto")
+ parser.add_argument("-a", action="store", dest="action")
+ parser.add_argument("-t", action="store", dest="test")
results = parser.parse_args()
action = results.action
test = results.test
run(results.mode, results.ip, results.port, results.proto)
- #if (len(sys.argv)) < 4:
+ # if (len(sys.argv)) < 4:
# raise Exception("Usage: ./dummy_app <mode> <ip> <port> [<action> <test>]")
- #if (len(sys.argv) == 6):
+ # if (len(sys.argv) == 6):
# action = sys.argv[4]
# test = int(sys.argv[5])
- #run (sys.argv[1], sys.argv[2], int(sys.argv[3]))
+ # run (sys.argv[1], sys.argv[2], int(sys.argv[3]))