tests: replace pycodestyle with black
Drop pycodestyle for code style checking in favor of black. Black is
much faster, stable PEP8 compliant code style checker offering also
automatic formatting. It aims to be very stable and produce smallest
diffs. It's used by many small and big projects.
Running checkstyle with black takes a few seconds with a terse output.
Thus, test-checkstyle-diff is no longer necessary.
Expand scope of checkstyle to all python files in the repo, replacing
test-checkstyle with checkstyle-python.
Also, fixstyle-python is now available for automatic style formatting.
Note: python virtualenv has been consolidated in test/Makefile,
test/requirements*.txt which will eventually be moved to a central
location. This is required to simply the automated generation of
docker executor images in the CI.
Type: improvement
Change-Id: I022a326603485f58585e879ac0f697fceefbc9c8
Signed-off-by: Klement Sekera <klement.sekera@gmail.com>
Signed-off-by: Dave Wallace <dwallacelf@gmail.com>
diff --git a/src/scripts/fts.py b/src/scripts/fts.py
index f2b877f..e8ff477 100755
--- a/src/scripts/fts.py
+++ b/src/scripts/fts.py
@@ -21,25 +21,28 @@
"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 @@
},
"features": {
"type": "array",
- "items": {"anyOf": [{"$ref": "#/definitions/featureobject"},
- {"type": "string"},
- ]},
+ "items": {
+ "anyOf": [
+ {"$ref": "#/definitions/featureobject"},
+ {"type": "string"},
+ ]
+ },
"minItems": 1,
},
},
@@ -59,14 +65,15 @@
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_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 @@
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 @@
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 @@
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 @@
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 @@
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 20f5bd6..f0296af 100755
--- a/src/scripts/host-stack/cc_plots.py
+++ b/src/scripts/host-stack/cc_plots.py
@@ -6,214 +6,242 @@
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)
+ 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"])
+ 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')
+ # 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])
+ 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)
+ # 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(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)
+ # 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])
+ # 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()
+ # show
+ plt.show()
-def find_pattern(file_path,session_idx):
+
+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 d96a378..7fab2d7 100755
--- a/src/scripts/vnet/uri/dummy_app.py
+++ b/src/scripts/vnet/uri/dummy_app.py
@@ -5,34 +5,41 @@
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 @@
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 @@
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 @@
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 @@
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]))