Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 3 | '''Phosphor Inventory Manager YAML parser and code generator. |
| 4 | |
| 5 | The parser workflow is broken down as follows: |
| 6 | 1 - Import YAML files as native python type(s) instance(s). |
| 7 | 2 - Create an instance of the Everything class from the |
| 8 | native python type instance(s) with the Everything.load |
| 9 | method. |
| 10 | 3 - The Everything class constructor orchestrates conversion of the |
| 11 | native python type(s) instances(s) to render helper types. |
| 12 | Each render helper type constructor imports its attributes |
| 13 | from the native python type(s) instances(s). |
| 14 | 4 - Present the converted YAML to the command processing method |
| 15 | requested by the script user. |
| 16 | ''' |
| 17 | |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 18 | import sys |
| 19 | import os |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 20 | import argparse |
Brad Bishop | cfb3c89 | 2016-11-12 11:43:37 -0500 | [diff] [blame] | 21 | import subprocess |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 22 | import yaml |
| 23 | import mako.lookup |
| 24 | import sdbusplus.property |
| 25 | from sdbusplus.namedelement import NamedElement |
| 26 | from sdbusplus.renderer import Renderer |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 27 | |
| 28 | |
Brad Bishop | 9b5a12f | 2017-01-21 14:42:11 -0500 | [diff] [blame] | 29 | def cppTypeName(yaml_type): |
| 30 | ''' Convert yaml types to cpp types.''' |
| 31 | return sdbusplus.property.Property(type=yaml_type).cppTypeName |
| 32 | |
| 33 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 34 | class Interface(list): |
| 35 | '''Provide various interface transformations.''' |
| 36 | |
| 37 | def __init__(self, iface): |
| 38 | super(Interface, self).__init__(iface.split('.')) |
| 39 | |
| 40 | def namespace(self): |
| 41 | '''Represent as an sdbusplus namespace.''' |
| 42 | return '::'.join(['sdbusplus'] + self[:-1] + ['server', self[-1]]) |
| 43 | |
| 44 | def header(self): |
| 45 | '''Represent as an sdbusplus server binding header.''' |
| 46 | return os.sep.join(self + ['server.hpp']) |
| 47 | |
| 48 | def __str__(self): |
| 49 | return '.'.join(self) |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 50 | |
Brad Bishop | cfb3c89 | 2016-11-12 11:43:37 -0500 | [diff] [blame] | 51 | |
Brad Bishop | 9b5a12f | 2017-01-21 14:42:11 -0500 | [diff] [blame] | 52 | class Indent(object): |
| 53 | '''Help templates be depth agnostic.''' |
| 54 | |
| 55 | def __init__(self, depth=0): |
| 56 | self.depth = depth |
| 57 | |
| 58 | def __add__(self, depth): |
| 59 | return Indent(self.depth + depth) |
| 60 | |
| 61 | def __call__(self, depth): |
| 62 | '''Render an indent at the current depth plus depth.''' |
| 63 | return 4*' '*(depth + self.depth) |
| 64 | |
| 65 | |
| 66 | class Template(NamedElement): |
| 67 | '''Associate a template name with its namespace.''' |
| 68 | |
| 69 | def __init__(self, **kw): |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 70 | self.namespace = kw.pop('namespace', []) |
Brad Bishop | 9b5a12f | 2017-01-21 14:42:11 -0500 | [diff] [blame] | 71 | super(Template, self).__init__(**kw) |
| 72 | |
| 73 | def qualified(self): |
| 74 | return '::'.join(self.namespace + [self.name]) |
| 75 | |
| 76 | |
| 77 | class Quote(object): |
| 78 | '''Decorate an argument by quoting it.''' |
| 79 | |
| 80 | def __call__(self, arg): |
| 81 | return '"{0}"'.format(arg) |
| 82 | |
| 83 | |
| 84 | class Cast(object): |
| 85 | '''Decorate an argument by casting it.''' |
| 86 | |
| 87 | def __init__(self, cast, target): |
| 88 | '''cast is the cast type (static, const, etc...). |
| 89 | target is the cast target type.''' |
| 90 | self.cast = cast |
| 91 | self.target = target |
| 92 | |
| 93 | def __call__(self, arg): |
| 94 | return '{0}_cast<{1}>({2})'.format(self.cast, self.target, arg) |
| 95 | |
| 96 | |
| 97 | class Literal(object): |
| 98 | '''Decorate an argument with a literal operator.''' |
| 99 | |
| 100 | literals = { |
| 101 | 'string': 's', |
| 102 | 'int64': 'll', |
| 103 | 'uint64': 'ull' |
| 104 | } |
| 105 | |
| 106 | def __init__(self, type): |
| 107 | self.type = type |
| 108 | |
| 109 | def __call__(self, arg): |
| 110 | literal = self.literals.get(self.type) |
| 111 | |
| 112 | if literal: |
| 113 | return '{0}{1}'.format(arg, literal) |
| 114 | |
| 115 | return arg |
| 116 | |
| 117 | |
Brad Bishop | 75800cf | 2017-01-21 15:24:18 -0500 | [diff] [blame] | 118 | class Argument(NamedElement, Renderer): |
| 119 | '''Define argument type inteface.''' |
| 120 | |
| 121 | def __init__(self, **kw): |
| 122 | self.type = kw.pop('type', None) |
| 123 | super(Argument, self).__init__(**kw) |
| 124 | |
| 125 | def argument(self, loader, indent): |
| 126 | raise NotImplementedError |
| 127 | |
| 128 | |
| 129 | class TrivialArgument(Argument): |
| 130 | '''Non-array type arguments.''' |
Brad Bishop | 14a9fe5 | 2016-11-12 12:51:26 -0500 | [diff] [blame] | 131 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 132 | def __init__(self, **kw): |
| 133 | self.value = kw.pop('value') |
Brad Bishop | 75800cf | 2017-01-21 15:24:18 -0500 | [diff] [blame] | 134 | self.decorators = kw.pop('decorators', []) |
| 135 | if kw.get('type', None) == 'string': |
| 136 | self.decorators.insert(0, Quote()) |
| 137 | |
Brad Bishop | 75800cf | 2017-01-21 15:24:18 -0500 | [diff] [blame] | 138 | super(TrivialArgument, self).__init__(**kw) |
| 139 | |
| 140 | def argument(self, loader, indent): |
| 141 | a = str(self.value) |
| 142 | for d in self.decorators: |
| 143 | a = d(a) |
| 144 | |
| 145 | return a |
Brad Bishop | 14a9fe5 | 2016-11-12 12:51:26 -0500 | [diff] [blame] | 146 | |
Brad Bishop | 14a9fe5 | 2016-11-12 12:51:26 -0500 | [diff] [blame] | 147 | |
Brad Bishop | 9b5a12f | 2017-01-21 14:42:11 -0500 | [diff] [blame] | 148 | class InitializerList(Argument): |
| 149 | '''Initializer list arguments.''' |
| 150 | |
| 151 | def __init__(self, **kw): |
| 152 | self.values = kw.pop('values') |
| 153 | super(InitializerList, self).__init__(**kw) |
| 154 | |
| 155 | def argument(self, loader, indent): |
| 156 | return self.render( |
| 157 | loader, |
| 158 | 'argument.mako.cpp', |
| 159 | arg=self, |
| 160 | indent=indent) |
| 161 | |
| 162 | |
Brad Bishop | 75800cf | 2017-01-21 15:24:18 -0500 | [diff] [blame] | 163 | class DbusSignature(Argument): |
| 164 | '''DBus signature arguments.''' |
| 165 | |
| 166 | def __init__(self, **kw): |
| 167 | self.sig = {x: y for x, y in kw.iteritems()} |
| 168 | kw.clear() |
| 169 | super(DbusSignature, self).__init__(**kw) |
| 170 | |
| 171 | def argument(self, loader, indent): |
| 172 | return self.render( |
| 173 | loader, |
| 174 | 'signature.mako.cpp', |
| 175 | signature=self, |
| 176 | indent=indent) |
| 177 | |
| 178 | |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 179 | class MethodCall(Argument): |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 180 | '''Render syntatically correct c++ method calls.''' |
| 181 | |
| 182 | def __init__(self, **kw): |
| 183 | self.namespace = kw.pop('namespace', []) |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 184 | self.templates = kw.pop('templates', []) |
| 185 | self.args = kw.pop('args', []) |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 186 | super(MethodCall, self).__init__(**kw) |
| 187 | |
Brad Bishop | cab2bdd | 2017-01-21 15:00:54 -0500 | [diff] [blame] | 188 | def call(self, loader, indent): |
| 189 | return self.render( |
| 190 | loader, |
| 191 | 'method.mako.cpp', |
| 192 | method=self, |
| 193 | indent=indent) |
| 194 | |
| 195 | def argument(self, loader, indent): |
| 196 | return self.call(loader, indent) |
| 197 | |
Brad Bishop | 14a9fe5 | 2016-11-12 12:51:26 -0500 | [diff] [blame] | 198 | |
Brad Bishop | 9b5a12f | 2017-01-21 14:42:11 -0500 | [diff] [blame] | 199 | class Vector(MethodCall): |
| 200 | '''Convenience type for vectors.''' |
| 201 | |
| 202 | def __init__(self, **kw): |
| 203 | kw['name'] = 'vector' |
| 204 | kw['namespace'] = ['std'] |
| 205 | kw['args'] = [InitializerList(values=kw.pop('args'))] |
| 206 | super(Vector, self).__init__(**kw) |
| 207 | |
| 208 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 209 | class Filter(MethodCall): |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 210 | '''Convenience type for filters''' |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 211 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 212 | def __init__(self, **kw): |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 213 | kw['name'] = 'make_filter' |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 214 | super(Filter, self).__init__(**kw) |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 215 | |
Brad Bishop | 0a6a479 | 2016-11-12 12:10:07 -0500 | [diff] [blame] | 216 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 217 | class Action(MethodCall): |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 218 | '''Convenience type for actions''' |
Brad Bishop | 561a565 | 2016-10-26 21:13:32 -0500 | [diff] [blame] | 219 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 220 | def __init__(self, **kw): |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 221 | kw['name'] = 'make_action' |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 222 | super(Action, self).__init__(**kw) |
Brad Bishop | 92665b2 | 2016-10-26 20:51:16 -0500 | [diff] [blame] | 223 | |
Brad Bishop | cfb3c89 | 2016-11-12 11:43:37 -0500 | [diff] [blame] | 224 | |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 225 | class PathCondition(MethodCall): |
| 226 | '''Convenience type for path conditions''' |
| 227 | |
| 228 | def __init__(self, **kw): |
| 229 | kw['name'] = 'make_path_condition' |
| 230 | super(PathCondition, self).__init__(**kw) |
| 231 | |
| 232 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 233 | class CreateObjects(MethodCall): |
| 234 | '''Assemble a createObjects functor.''' |
Brad Bishop | db92c28 | 2017-01-21 23:44:28 -0500 | [diff] [blame] | 235 | |
| 236 | def __init__(self, **kw): |
| 237 | objs = [] |
| 238 | |
| 239 | for path, interfaces in kw.pop('objs').iteritems(): |
| 240 | key_o = TrivialArgument( |
| 241 | value=path, |
| 242 | type='string', |
| 243 | decorators=[Literal('string')]) |
| 244 | value_i = [] |
| 245 | |
| 246 | for interface, properties, in interfaces.iteritems(): |
| 247 | key_i = TrivialArgument(value=interface, type='string') |
| 248 | value_p = [] |
| 249 | |
| 250 | for prop, value in properties.iteritems(): |
| 251 | key_p = TrivialArgument(value=prop, type='string') |
| 252 | value_v = TrivialArgument( |
| 253 | decorators=[Literal(value.get('type', None))], |
| 254 | **value) |
| 255 | value_p.append(InitializerList(values=[key_p, value_v])) |
| 256 | |
| 257 | value_p = InitializerList(values=value_p) |
| 258 | value_i.append(InitializerList(values=[key_i, value_p])) |
| 259 | |
| 260 | value_i = InitializerList(values=value_i) |
| 261 | objs.append(InitializerList(values=[key_o, value_i])) |
| 262 | |
| 263 | kw['args'] = [InitializerList(values=objs)] |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 264 | kw['namespace'] = ['functor'] |
Brad Bishop | db92c28 | 2017-01-21 23:44:28 -0500 | [diff] [blame] | 265 | super(CreateObjects, self).__init__(**kw) |
| 266 | |
| 267 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 268 | class DestroyObjects(MethodCall): |
| 269 | '''Assemble a destroyObject functor.''' |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 270 | |
| 271 | def __init__(self, **kw): |
Brad Bishop | 7b7e712 | 2017-01-21 21:21:46 -0500 | [diff] [blame] | 272 | values = [{'value': x, 'type': 'string'} for x in kw.pop('paths')] |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 273 | conditions = [ |
| 274 | Event.functor_map[ |
| 275 | x['name']](**x) for x in kw.pop('conditions', [])] |
| 276 | conditions = [PathCondition(args=[x]) for x in conditions] |
Brad Bishop | 7b7e712 | 2017-01-21 21:21:46 -0500 | [diff] [blame] | 277 | args = [InitializerList( |
| 278 | values=[TrivialArgument(**x) for x in values])] |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 279 | args.append(InitializerList(values=conditions)) |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 280 | kw['args'] = args |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 281 | kw['namespace'] = ['functor'] |
Brad Bishop | 7b7e712 | 2017-01-21 21:21:46 -0500 | [diff] [blame] | 282 | super(DestroyObjects, self).__init__(**kw) |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 283 | |
| 284 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 285 | class SetProperty(MethodCall): |
| 286 | '''Assemble a setProperty functor.''' |
Brad Bishop | e2e402f | 2016-11-30 18:00:17 -0500 | [diff] [blame] | 287 | |
| 288 | def __init__(self, **kw): |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 289 | args = [] |
| 290 | |
| 291 | value = kw.pop('value') |
| 292 | prop = kw.pop('property') |
| 293 | iface = kw.pop('interface') |
| 294 | iface = Interface(iface) |
| 295 | namespace = iface.namespace().split('::')[:-1] |
| 296 | name = iface[-1] |
| 297 | t = Template(namespace=namespace, name=iface[-1]) |
| 298 | |
Brad Bishop | e2e402f | 2016-11-30 18:00:17 -0500 | [diff] [blame] | 299 | member = '&%s' % '::'.join( |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 300 | namespace + [name, NamedElement(name=prop).camelCase]) |
| 301 | member_type = cppTypeName(value['type']) |
| 302 | member_cast = '{0} ({1}::*)({0})'.format(member_type, t.qualified()) |
Brad Bishop | e2e402f | 2016-11-30 18:00:17 -0500 | [diff] [blame] | 303 | |
Brad Bishop | 02ca021 | 2017-01-28 23:25:58 -0500 | [diff] [blame] | 304 | paths = [{'value': x, 'type': 'string'} for x in kw.pop('paths')] |
| 305 | args.append(InitializerList( |
| 306 | values=[TrivialArgument(**x) for x in paths])) |
| 307 | |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 308 | conditions = [ |
| 309 | Event.functor_map[ |
| 310 | x['name']](**x) for x in kw.pop('conditions', [])] |
| 311 | conditions = [PathCondition(args=[x]) for x in conditions] |
| 312 | |
| 313 | args.append(InitializerList(values=conditions)) |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 314 | args.append(TrivialArgument(value=str(iface), type='string')) |
| 315 | args.append(TrivialArgument( |
| 316 | value=member, decorators=[Cast('static', member_cast)])) |
| 317 | args.append(TrivialArgument(**value)) |
Brad Bishop | e2e402f | 2016-11-30 18:00:17 -0500 | [diff] [blame] | 318 | |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 319 | kw['templates'] = [Template(name=name, namespace=namespace)] |
| 320 | kw['args'] = args |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 321 | kw['namespace'] = ['functor'] |
Brad Bishop | e2e402f | 2016-11-30 18:00:17 -0500 | [diff] [blame] | 322 | super(SetProperty, self).__init__(**kw) |
| 323 | |
| 324 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 325 | class PropertyChanged(MethodCall): |
| 326 | '''Assemble a propertyChanged functor.''' |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 327 | |
| 328 | def __init__(self, **kw): |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 329 | args = [] |
| 330 | args.append(TrivialArgument(value=kw.pop('interface'), type='string')) |
| 331 | args.append(TrivialArgument(value=kw.pop('property'), type='string')) |
| 332 | args.append(TrivialArgument( |
| 333 | decorators=[ |
| 334 | Literal(kw['value'].get('type', None))], **kw.pop('value'))) |
| 335 | kw['args'] = args |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 336 | kw['namespace'] = ['functor'] |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 337 | super(PropertyChanged, self).__init__(**kw) |
| 338 | |
| 339 | |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 340 | class PropertyIs(MethodCall): |
| 341 | '''Assemble a propertyIs functor.''' |
Brad Bishop | 040e18b | 2017-01-21 22:04:00 -0500 | [diff] [blame] | 342 | |
| 343 | def __init__(self, **kw): |
| 344 | args = [] |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 345 | path = kw.pop('path', None) |
| 346 | if not path: |
| 347 | path = TrivialArgument(value='nullptr') |
| 348 | else: |
| 349 | path = TrivialArgument(value=path, type='string') |
| 350 | |
| 351 | args.append(path) |
Brad Bishop | 040e18b | 2017-01-21 22:04:00 -0500 | [diff] [blame] | 352 | args.append(TrivialArgument(value=kw.pop('interface'), type='string')) |
| 353 | args.append(TrivialArgument(value=kw.pop('property'), type='string')) |
| 354 | args.append(TrivialArgument( |
| 355 | decorators=[ |
| 356 | Literal(kw['value'].get('type', None))], **kw.pop('value'))) |
| 357 | |
| 358 | service = kw.pop('service', None) |
| 359 | if service: |
| 360 | args.append(TrivialArgument(value=service, type='string')) |
| 361 | |
| 362 | kw['args'] = args |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 363 | kw['namespace'] = ['functor'] |
Brad Bishop | 040e18b | 2017-01-21 22:04:00 -0500 | [diff] [blame] | 364 | super(PropertyIs, self).__init__(**kw) |
| 365 | |
| 366 | |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 367 | class Event(MethodCall): |
| 368 | '''Assemble an inventory manager event.''' |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 369 | |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 370 | functor_map = { |
Brad Bishop | 7b7e712 | 2017-01-21 21:21:46 -0500 | [diff] [blame] | 371 | 'destroyObjects': DestroyObjects, |
Brad Bishop | db92c28 | 2017-01-21 23:44:28 -0500 | [diff] [blame] | 372 | 'createObjects': CreateObjects, |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 373 | 'propertyChangedTo': PropertyChanged, |
Brad Bishop | 040e18b | 2017-01-21 22:04:00 -0500 | [diff] [blame] | 374 | 'propertyIs': PropertyIs, |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 375 | 'setProperty': SetProperty, |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 376 | } |
| 377 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 378 | def __init__(self, **kw): |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 379 | self.summary = kw.pop('name') |
| 380 | |
| 381 | filters = [ |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 382 | self.functor_map[x['name']](**x) for x in kw.pop('filters', [])] |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 383 | filters = [Filter(args=[x]) for x in filters] |
Brad Bishop | 064c94a | 2017-01-21 21:33:30 -0500 | [diff] [blame] | 384 | filters = Vector( |
Brad Bishop | 12f8a3c | 2017-02-09 00:02:00 -0500 | [diff] [blame] | 385 | templates=[Template(name='Filter', namespace=[])], |
Brad Bishop | 064c94a | 2017-01-21 21:33:30 -0500 | [diff] [blame] | 386 | args=filters) |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 387 | |
| 388 | event = MethodCall( |
| 389 | name='make_shared', |
| 390 | namespace=['std'], |
| 391 | templates=[Template( |
| 392 | name=kw.pop('event'), |
| 393 | namespace=kw.pop('event_namespace', []))], |
Brad Bishop | 064c94a | 2017-01-21 21:33:30 -0500 | [diff] [blame] | 394 | args=kw.pop('event_args', []) + [filters]) |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 395 | |
| 396 | events = Vector( |
Brad Bishop | 12f8a3c | 2017-02-09 00:02:00 -0500 | [diff] [blame] | 397 | templates=[Template(name='EventBasePtr', namespace=[])], |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 398 | args=[event]) |
| 399 | |
Brad Bishop | 12f8a3c | 2017-02-09 00:02:00 -0500 | [diff] [blame] | 400 | action_type = Template(name='Action', namespace=[]) |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 401 | action_args = [ |
Brad Bishop | d0f48ad | 2017-01-30 08:52:26 -0500 | [diff] [blame^] | 402 | self.functor_map[x['name']](**x) for x in kw.pop('actions', [])] |
Brad Bishop | c1f4798 | 2017-02-09 01:27:38 -0500 | [diff] [blame] | 403 | action_args = [Action(args=[x]) for x in action_args] |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 404 | actions = Vector( |
| 405 | templates=[action_type], |
| 406 | args=action_args) |
| 407 | |
| 408 | kw['name'] = 'make_tuple' |
| 409 | kw['namespace'] = ['std'] |
| 410 | kw['args'] = [events, actions] |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 411 | super(Event, self).__init__(**kw) |
Brad Bishop | cfb3c89 | 2016-11-12 11:43:37 -0500 | [diff] [blame] | 412 | |
Brad Bishop | cfb3c89 | 2016-11-12 11:43:37 -0500 | [diff] [blame] | 413 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 414 | class MatchEvent(Event): |
| 415 | '''Associate one or more dbus signal match signatures with |
| 416 | a filter.''' |
| 417 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 418 | def __init__(self, **kw): |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 419 | kw['event'] = 'DbusSignal' |
Brad Bishop | 12f8a3c | 2017-02-09 00:02:00 -0500 | [diff] [blame] | 420 | kw['event_namespace'] = [] |
Brad Bishop | c93bcc9 | 2017-01-21 16:23:39 -0500 | [diff] [blame] | 421 | kw['event_args'] = [ |
| 422 | DbusSignature(**x) for x in kw.pop('signatures', [])] |
| 423 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 424 | super(MatchEvent, self).__init__(**kw) |
| 425 | |
| 426 | |
Brad Bishop | 828df83 | 2017-01-21 22:20:43 -0500 | [diff] [blame] | 427 | class StartupEvent(Event): |
| 428 | '''Assemble a startup event.''' |
| 429 | |
| 430 | def __init__(self, **kw): |
| 431 | kw['event'] = 'StartupEvent' |
Brad Bishop | 12f8a3c | 2017-02-09 00:02:00 -0500 | [diff] [blame] | 432 | kw['event_namespace'] = [] |
Brad Bishop | 828df83 | 2017-01-21 22:20:43 -0500 | [diff] [blame] | 433 | super(StartupEvent, self).__init__(**kw) |
| 434 | |
| 435 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 436 | class Everything(Renderer): |
| 437 | '''Parse/render entry point.''' |
| 438 | |
| 439 | class_map = { |
| 440 | 'match': MatchEvent, |
Brad Bishop | 828df83 | 2017-01-21 22:20:43 -0500 | [diff] [blame] | 441 | 'startup': StartupEvent, |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 442 | } |
| 443 | |
| 444 | @staticmethod |
| 445 | def load(args): |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 446 | # Aggregate all the event YAML in the events.d directory |
| 447 | # into a single list of events. |
| 448 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 449 | events = [] |
Brad Bishop | a6fcd56 | 2017-02-03 11:00:27 -0500 | [diff] [blame] | 450 | events_dir = os.path.join(args.inputdir, 'events.d') |
| 451 | |
| 452 | if os.path.exists(events_dir): |
| 453 | yaml_files = filter( |
| 454 | lambda x: x.endswith('.yaml'), |
| 455 | os.listdir(events_dir)) |
| 456 | |
| 457 | for x in yaml_files: |
| 458 | with open(os.path.join(events_dir, x), 'r') as fd: |
| 459 | for e in yaml.safe_load(fd.read()).get('events', {}): |
| 460 | events.append(e) |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 461 | |
| 462 | return Everything( |
| 463 | *events, |
| 464 | interfaces=Everything.get_interfaces(args)) |
| 465 | |
| 466 | @staticmethod |
| 467 | def get_interfaces(args): |
| 468 | '''Aggregate all the interface YAML in the interfaces.d |
| 469 | directory into a single list of interfaces.''' |
| 470 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 471 | interfaces = [] |
Brad Bishop | a6fcd56 | 2017-02-03 11:00:27 -0500 | [diff] [blame] | 472 | interfaces_dir = os.path.join(args.inputdir, 'interfaces.d') |
| 473 | if os.path.exists(interfaces_dir): |
| 474 | yaml_files = filter( |
| 475 | lambda x: x.endswith('.yaml'), |
| 476 | os.listdir(interfaces_dir)) |
| 477 | |
| 478 | for x in yaml_files: |
| 479 | with open(os.path.join(interfaces_dir, x), 'r') as fd: |
| 480 | for i in yaml.safe_load(fd.read()): |
| 481 | interfaces.append(i) |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 482 | |
| 483 | return interfaces |
| 484 | |
| 485 | def __init__(self, *a, **kw): |
| 486 | self.interfaces = \ |
| 487 | [Interface(x) for x in kw.pop('interfaces', [])] |
| 488 | self.events = [ |
| 489 | self.class_map[x['type']](**x) for x in a] |
| 490 | super(Everything, self).__init__(**kw) |
| 491 | |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 492 | def generate_cpp(self, loader): |
| 493 | '''Render the template with the provided events and interfaces.''' |
| 494 | with open(os.path.join( |
| 495 | args.outputdir, |
| 496 | 'generated.cpp'), 'w') as fd: |
| 497 | fd.write( |
| 498 | self.render( |
| 499 | loader, |
| 500 | 'generated.mako.cpp', |
| 501 | events=self.events, |
Brad Bishop | 9b5a12f | 2017-01-21 14:42:11 -0500 | [diff] [blame] | 502 | interfaces=self.interfaces, |
| 503 | indent=Indent())) |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 504 | |
Brad Bishop | 95dd98f | 2016-11-12 12:39:15 -0500 | [diff] [blame] | 505 | |
| 506 | if __name__ == '__main__': |
| 507 | script_dir = os.path.dirname(os.path.realpath(__file__)) |
Brad Bishop | 14a9fe5 | 2016-11-12 12:51:26 -0500 | [diff] [blame] | 508 | valid_commands = { |
| 509 | 'generate-cpp': 'generate_cpp', |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 510 | } |
Brad Bishop | 95dd98f | 2016-11-12 12:39:15 -0500 | [diff] [blame] | 511 | |
| 512 | parser = argparse.ArgumentParser( |
| 513 | description='Phosphor Inventory Manager (PIM) YAML ' |
| 514 | 'scanner and code generator.') |
| 515 | parser.add_argument( |
| 516 | '-o', '--output-dir', dest='outputdir', |
| 517 | default='.', help='Output directory.') |
| 518 | parser.add_argument( |
| 519 | '-d', '--dir', dest='inputdir', |
| 520 | default=os.path.join(script_dir, 'example'), |
| 521 | help='Location of files to process.') |
Brad Bishop | f4666f5 | 2016-11-12 12:44:42 -0500 | [diff] [blame] | 522 | parser.add_argument( |
| 523 | 'command', metavar='COMMAND', type=str, |
| 524 | choices=valid_commands.keys(), |
Brad Bishop | c029f6a | 2017-01-18 19:43:26 -0500 | [diff] [blame] | 525 | help='%s.' % " | ".join(valid_commands.keys())) |
Brad Bishop | 95dd98f | 2016-11-12 12:39:15 -0500 | [diff] [blame] | 526 | |
| 527 | args = parser.parse_args() |
Brad Bishop | 22cfbe6 | 2016-11-30 13:25:10 -0500 | [diff] [blame] | 528 | |
| 529 | if sys.version_info < (3, 0): |
| 530 | lookup = mako.lookup.TemplateLookup( |
| 531 | directories=[script_dir], |
| 532 | disable_unicode=True) |
| 533 | else: |
| 534 | lookup = mako.lookup.TemplateLookup( |
| 535 | directories=[script_dir]) |
| 536 | |
| 537 | function = getattr( |
| 538 | Everything.load(args), |
| 539 | valid_commands[args.command]) |
| 540 | function(lookup) |
Brad Bishop | 95dd98f | 2016-11-12 12:39:15 -0500 | [diff] [blame] | 541 | |
| 542 | |
Brad Bishop | bf066a6 | 2016-10-19 08:09:44 -0400 | [diff] [blame] | 543 | # vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4 |