| #!/usr/bin/env python3 |
| |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| |
| from typing import List |
| import optparse |
| import fileinput |
| import json |
| import re |
| import sys |
| |
| """ |
| This program accepts input for a modified Scraper and produces output to create sequence diagrams |
| at sequencediagram.org. |
| """ |
| |
| IDX_DATETIME = 0 |
| IDX_NAME_LEFT = 1 |
| IDX_DIR = 2 |
| IDX_NAME_RIGHT = 3 |
| IDX_PERFORMATIVE = 4 |
| IDX_ROUTER_LINE = 5 |
| |
| # Exactly how to predict how much 'space' asynchronous messages take is vague. |
| MAGIC_SPACE_NUMBER = 1 # tested with entryspacing 0.1 |
| |
| |
| class log_record: |
| def __init__(self, index, line): |
| # print("DEBUG input line: ", index, line) |
| dateandtime, name_left, direction, name_right, perf, router_line, dummy = line.split('|') |
| self.dateandtime = dateandtime.strip() |
| self.time = self.dateandtime.split(' ')[1] |
| self.index = index |
| self.name_left = name_left.strip() |
| self.direction = direction.strip() |
| self.name_right = name_right.strip() |
| self.performative = perf.strip() |
| self.router_line = router_line.strip() # diag |
| self.peer_log_rec = None |
| dir_out = (direction == '->') # name_left -> name_right |
| self.sentby = name_left.strip() if dir_out else name_right.strip() |
| self.rcvdby = name_right.strip() if dir_out else name_left.strip() |
| |
| def absorb_peer_rec(self, peer_rec): |
| ''' |
| Given peer_rec, see if it is the receiving side of |
| this log_rec being sent. If so then cross-link the |
| records and return true. |
| :param peer_rec: |
| :return: |
| ''' |
| valid_peer = self.name_left == peer_rec.name_right and \ |
| self.name_right == peer_rec.name_left and \ |
| self.direction != peer_rec.direction and \ |
| self.performative.startswith(peer_rec.performative) and \ |
| self.peer_log_rec is None and \ |
| peer_rec.peer_log_rec is None |
| if not valid_peer: |
| return False |
| self.peer_log_rec = peer_rec |
| peer_rec.peer_log_rec = self |
| return True |
| |
| def show_for_sdorg(self, showtime): |
| # A single sd.org vector consumes one or two log lines. |
| # One if from an external actor. |
| # Two if a message goes between routers. |
| # Leave space where the message is supposed to land in the receiving routers |
| if self.peer_log_rec is None: |
| if showtime: |
| print("%s->%s:%s %s" % (self.sentby, self.rcvdby, self.time, self.performative)) |
| else: |
| print("%s->%s:%s" % (self.sentby, self.rcvdby, self.performative)) |
| else: |
| if self.peer_log_rec.index > self.index: |
| linediff = int(self.peer_log_rec.index) - int(self.index) |
| space = -MAGIC_SPACE_NUMBER * (linediff - 1) |
| if showtime: |
| print("%s->(%s)%s:%s %s" % (self.sentby, str(linediff), self.rcvdby, self.time, self.performative)) |
| else: |
| print("%s->(%s)%s:%s" % (self.sentby, str(linediff), self.rcvdby, self.performative)) |
| print("space %s" % (str(space))) |
| else: |
| print("space %d" % MAGIC_SPACE_NUMBER) |
| |
| def sender_receiver(self): |
| # Return sender receiver |
| return self.sentby, self.rcvdby |
| |
| def diag_dump(self): |
| cmn = ("index: %d, dateandtime: %s, sentby: %s, rcvdby: %s, performative: %s, router_line: %s" % |
| (self.dateandtime, self.index, self.sentby, self.rcvdby, self.performative, self.router_line)) |
| if self.peer_log_rec is None: |
| print(cmn) |
| else: |
| print("%s, PEER MATCH peer_index: %s, peer_router_log_line: %s" % |
| (cmn, self.peer_log_rec.index, self.peer_log_rec.router_line)) |
| |
| |
| def split_log_file(filename): |
| ''' |
| Given a filename, read the file into an array of lines |
| :param filename: |
| :return: |
| ''' |
| if filename == "STDIN" or filename == "" or filename == "-": |
| log = sys.stdin |
| log_lines = log.read().split("\n") |
| else: |
| log = open(filename, 'r') |
| log_lines = log.read().split("\n") |
| log.close() |
| return log_lines |
| |
| |
| def match_logline_pairs(log_recs): |
| ''' |
| Given a log line that might be the source of a message to another router, |
| search the list of remaining log lines and try to find the router that received |
| this message. Then hook them together. |
| The cut of Scraper output presented as input to this program may not be complete. |
| Messages for which there is no 'match' are drawn as horizontal lines. |
| :param log_lines: |
| :return: |
| ''' |
| for idx in range(len(log_recs) - 2): |
| for idx2 in range(idx + 1, len(log_recs) - 1): |
| if log_recs[idx].absorb_peer_rec(log_recs[idx2]): |
| break |
| |
| |
| if __name__ == "__main__": |
| parser = optparse.OptionParser(usage="%prog [options]", |
| description="cooks a scraper log snippet into sequence diagram source") |
| parser.add_option("-f", "--filename", action="append", help="logfile to use or - for stdin") |
| parser.add_option('--timestamp', '-t', |
| action='store_true', |
| help='Include HH:MM:SS.ssssss in output') |
| |
| (opts, args) = parser.parse_args() |
| if not opts.filename: |
| opts.filename = ["-"] |
| |
| log_recs = [] |
| for logfile in opts.filename: |
| # print("Parsing: %s" % logfile) |
| log_lines = split_log_file(logfile) |
| if len(log_lines) >= 2: |
| index = 0 |
| for logline in log_lines: |
| if len(logline) > 0: |
| log_recs.append(log_record(index, logline)) |
| index += 1 |
| match_logline_pairs(log_recs) |
| |
| # print senders and receivers marking as actor or participant |
| names = set() |
| for log_rec in log_recs: |
| sndr, rcvr = log_rec.sender_receiver() |
| if sndr is not None: |
| names.add(sndr) |
| if rcvr is not None: |
| names.add(rcvr) |
| for name in names: |
| if name.startswith("peer"): |
| print("actor %s" % name) |
| else: |
| print("participant %s" % name) |
| print() |
| |
| # process the list of records |
| for log_rec in log_recs: |
| log_rec.show_for_sdorg(opts.timestamp) |
| |
| # diag dump |
| #print("\nDiag dump") |
| # for log_rec in log_recs: |
| # log_rec.diag_dump() |
| else: |
| print("Log file has fewer than two lines. I give up.") |
| print() |
