src/scripts/fts.py

   1 #!/usr/bin/env python3
   2
   3 import sys
   4 import os
   5 import ipaddress
   6 import yaml
   7 from pprint import pprint
   8 import re
   9 from jsonschema import validate, exceptions
  10 import argparse
  11 from subprocess import run, PIPE
  12 from io import StringIO
  13
  14 # VPP feature JSON schema
  15 schema = {
  16     "$schema": "http://json-schema.org/schema#",
  17     "type": "object",
  18     "properties": {
  19         "name": {"type": "string"},
  20         "description": {"type": "string"},
  21         "maintainer": {"$ref": "#/definitions/maintainers"},
  22         "state": {"type": "string",
  23                   "enum": ["production", "experimental", "development"]},
  24         "features": {"$ref": "#/definitions/features"},
  25         "missing": {"$ref": "#/definitions/features"},
  26         "properties": {"type": "array",
  27                        "items": {"type": "string",
  28                                  "enum": ["API", "CLI", "STATS",
  29                                           "MULTITHREAD"]},
  30                        },
  31     },
  32     "additionalProperties": False,
  33     "definitions": {
  34         "maintainers": {
  35             "anyof": [{
  36                 "type": "array",
  37                 "items": {"type": "string"},
  38                 "minItems": 1,
  39             },
  40                 {"type": "string"}],
  41         },
  42         "featureobject": {
  43             "type": "object",
  44             "patternProperties": {
  45                 "^.*$": {"$ref": "#/definitions/features"},
  46             },
  47         },
  48         "features": {
  49             "type": "array",
  50             "items": {"anyOf": [{"$ref": "#/definitions/featureobject"},
  51                                 {"type": "string"},
  52                                 ]},
  53             "minItems": 1,
  54         },
  55     },
  56 }
  57
  58
  59 def filelist_from_git_status():
  60     filelist = []
  61     git_status = 'git status --porcelain */FEATURE.yaml'
  62     rv = run(git_status.split(), stdout=PIPE, stderr=PIPE)
  63     if rv.returncode != 0:
  64         sys.exit(rv.returncode)
  65
  66     for l in rv.stdout.decode('ascii').split('\n'):
  67         if len(l):
  68             filelist.append(l.split()[1])
  69     return filelist
  70
  71
  72 def filelist_from_git_ls():
  73     filelist = []
  74     git_ls = 'git ls-files :(top)*/FEATURE.yaml'
  75     rv = run(git_ls.split(), stdout=PIPE, stderr=PIPE)
  76     if rv.returncode != 0:
  77         sys.exit(rv.returncode)
  78
  79     for l in rv.stdout.decode('ascii').split('\n'):
  80         if len(l):
  81             filelist.append(l)
  82     return filelist
  83
  84 def version_from_git():
  85     git_describe = 'git describe'
  86     rv = run(git_describe.split(), stdout=PIPE, stderr=PIPE)
  87     if rv.returncode != 0:
  88         sys.exit(rv.returncode)
  89     return rv.stdout.decode('ascii').split('\n')[0]
  90
  91 class MarkDown():
  92     _dispatch = {}
  93
  94     def __init__(self, stream):
  95         self.stream = stream
  96         self.toc = []
  97
  98     def print_maintainer(self, o):
  99         write = self.stream.write
 100         if type(o) is list:
 101             write('Maintainers: ' +
 102                   ', '.join(f'{m}' for m in
 103                             o) + '  \n')
 104         else:
 105             write(f'Maintainer: {o}  \n')
 106
 107     _dispatch['maintainer'] = print_maintainer
 108
 109     def print_features(self, o, indent=0):
 110         write = self.stream.write
 111         for f in o:
 112             indentstr = ' ' * indent
 113             if type(f) is dict:
 114                 for k, v in f.items():
 115                     write(f'{indentstr}- {k}\n')
 116                     self.print_features(v, indent + 2)
 117             else:
 118                 write(f'{indentstr}- {f}\n')
 119         write('\n')
 120     _dispatch['features'] = print_features
 121
 122     def print_markdown_header(self, o):
 123         write = self.stream.write
 124         write(f'## {o}\n')
 125         version = version_from_git()
 126         write(f'VPP version: {version}\n\n')
 127     _dispatch['markdown_header'] = print_markdown_header
 128
 129     def print_name(self, o):
 130         write = self.stream.write
 131         write(f'### {o}\n')
 132         self.toc.append(o)
 133     _dispatch['name'] = print_name
 134
 135     def print_description(self, o):
 136         write = self.stream.write
 137         write(f'\n{o}\n\n')
 138     _dispatch['description'] = print_description
 139
 140     def print_state(self, o):
 141         write = self.stream.write
 142         write(f'Feature maturity level: {o}  \n')
 143     _dispatch['state'] = print_state
 144
 145     def print_properties(self, o):
 146         write = self.stream.write
 147         write(f'Supports: {" ".join(o)}  \n')
 148     _dispatch['properties'] = print_properties
 149
 150     def print_missing(self, o):
 151         write = self.stream.write
 152         write('\nNot yet implemented:  \n')
 153         self.print_features(o)
 154     _dispatch['missing'] = print_missing
 155
 156     def print_code(self, o):
 157         write = self.stream.write
 158         write(f'Source Code: [{o}]({o}) \n')
 159     _dispatch['code'] = print_code
 160
 161     def print(self, t, o):
 162         write = self.stream.write
 163         if t in self._dispatch:
 164             self._dispatch[t](self, o,)
 165         else:
 166             write('NOT IMPLEMENTED: {t}\n')
 167
 168 def output_toc(toc, stream):
 169     write = stream.write
 170     write('## VPP Feature list:\n')
 171
 172     for t in toc:
 173         ref = t.lower().replace(' ', '-')
 174         write(f'[{t}](#{ref})  \n')
 175
 176 def featuresort(k):
 177     return k[1]['name']
 178
 179 def featurelistsort(k):
 180     orderedfields = {
 181         'name': 0,
 182         'maintainer': 1,
 183         'description': 2,
 184         'features': 3,
 185         'state': 4,
 186         'properties': 5,
 187         'missing': 6,
 188         'code': 7,
 189     }
 190     return orderedfields[k[0]]
 191
 192 def output_markdown(features, fields, notfields):
 193     stream = StringIO()
 194     m = MarkDown(stream)
 195     m.print('markdown_header', 'Feature Details:')
 196     for path, featuredef in sorted(features.items(), key=featuresort):
 197         codeurl = 'https://git.fd.io/vpp/tree/src/' + '/'.join(os.path.normpath(path).split('/')[1:-1])
 198         featuredef['code'] = codeurl
 199         for k, v in sorted(featuredef.items(), key=featurelistsort):
 200             if notfields:
 201                 if k not in notfields:
 202                     m.print(k, v)
 203             elif fields:
 204                 if k in fields:
 205                     m.print(k, v)
 206             else:
 207                 m.print(k, v)
 208
 209     tocstream = StringIO()
 210     output_toc(m.toc, tocstream)
 211     return tocstream, stream
 212
 213 def main():
 214     parser = argparse.ArgumentParser(description='VPP Feature List.')
 215     parser.add_argument('--validate', dest='validate', action='store_true',
 216                         help='validate the FEATURE.yaml file')
 217     parser.add_argument('--git-status', dest='git_status', action='store_true',
 218                         help='Get filelist from git status')
 219     parser.add_argument('--all', dest='all', action='store_true',
 220                         help='Validate all files in repository')
 221     parser.add_argument('--markdown', dest='markdown', action='store_true',
 222                         help='Output feature table in markdown')
 223     parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
 224                         default=sys.stdin)
 225     group = parser.add_mutually_exclusive_group()
 226     group.add_argument('--include', help='List of fields to include')
 227     group.add_argument('--exclude', help='List of fields to exclude')
 228     args = parser.parse_args()
 229     features = {}
 230
 231     if args.git_status:
 232         filelist = filelist_from_git_status()
 233     elif args.all:
 234         filelist = filelist_from_git_ls()
 235     else:
 236         filelist = args.infile
 237
 238     if args.include:
 239         fields = args.include.split(',')
 240     else:
 241         fields = []
 242     if args.exclude:
 243         notfields = args.exclude.split(',')
 244     else:
 245         notfields = []
 246
 247     for featurefile in filelist:
 248         featurefile = featurefile.rstrip()
 249
 250         # Load configuration file
 251         with open(featurefile) as f:
 252             cfg = yaml.load(f, Loader=yaml.SafeLoader)
 253         try:
 254             validate(instance=cfg, schema=schema)
 255         except exceptions.ValidationError:
 256             print('File does not validate: {featurefile}',
 257                   file=sys.stderr)
 258             raise
 259         features[featurefile] = cfg
 260
 261     if args.markdown:
 262         stream = StringIO()
 263         tocstream, stream = output_markdown(features, fields, notfields)
 264         print(tocstream.getvalue())
 265         print(stream.getvalue())
 266         stream.close()
 267
 268
 269 if __name__ == '__main__':
 270     main()