| |
| # Copyright 2017-present Open Networking Foundation |
| # |
| # Licensed 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. |
| |
| |
| import plyxproto.model as m |
| from plyxproto.helpers import Visitor |
| import argparse |
| import plyxproto.parser as plyxproto |
| import traceback |
| import sys |
| import jinja2 |
| import os |
| import copy |
| import pdb |
| |
| class MissingPolicyException(Exception): |
| pass |
| |
| def find_missing_policy_calls(name, policies, policy): |
| if isinstance(policy, dict): |
| (k, lst), = policy.items() |
| if k=='policy': |
| policy_name = lst[0] |
| if policy_name not in policies: raise MissingPolicyException("Policy %s invoked missing policy %s"%(name, policy_name)) |
| else: |
| for p in lst: |
| find_missing_policy_calls(name, policies, p) |
| elif isinstance(policy, list): |
| for p in lst: |
| find_missing_policy_calls(name, policies, p) |
| |
| def dotname_to_fqn(dotname): |
| b_names = [part.pval for part in dotname] |
| package = '.'.join(b_names[:-1]) |
| name = b_names[-1] |
| if package: |
| fqn = package + '.' + name |
| else: |
| fqn = name |
| return {'name': name, 'fqn': fqn, 'package': package} |
| |
| |
| def dotname_to_name(dotname): |
| b_names = [part.pval for part in dotname] |
| return '.'.join(b_names) |
| |
| |
| def count_messages(body): |
| count = 0 |
| for e in body: |
| if (type(e) == m.MessageDefinition): |
| count += 1 |
| return count |
| |
| |
| def count_fields(body): |
| count = 0 |
| for e in body: |
| if (type(e) in [m.LinkDefinition, m.FieldDefinition, m.LinkSpec]): |
| count += 1 |
| return count |
| |
| |
| def name_to_value(obj): |
| try: |
| value = obj.value.value.pval |
| except AttributeError: |
| try: |
| value = obj.value.value |
| except AttributeError: |
| value = obj.value.pval |
| |
| return value |
| |
| |
| class Stack(list): |
| def push(self, x): |
| self.append(x) |
| |
| |
| ''' XOS2Jinja overrides the underlying visitor pattern to transform the tree |
| in addition to traversing it ''' |
| |
| class XOS2Jinja(Visitor): |
| def __init__(self, args): |
| super(XOS2Jinja, self).__init__() |
| |
| self.stack = Stack() |
| self.models = {} |
| self.options = {} |
| self.package = None |
| self.message_options = {} |
| self.count_stack = Stack() |
| self.policies = {} |
| self.content = "" |
| self.offset = 0 |
| self.current_message_name = None |
| self.verbose = 0 |
| self.first_field = True |
| self.first_method = True |
| self.args = args |
| |
| def visit_PolicyDefinition(self, obj): |
| if self.package: |
| pname = '.'.join([self.package, obj.name.value.pval]) |
| else: |
| pname = obj.name.value.pval |
| |
| self.policies[pname] = obj.body |
| find_missing_policy_calls(pname, self.policies, obj.body) |
| |
| return True |
| |
| def visit_PackageStatement(self, obj): |
| dotlist = obj.name.value |
| dotlist2 = [f.pval for f in dotlist] |
| dotstr = '.'.join(dotlist2) |
| self.package = dotstr |
| return True |
| |
| def visit_ImportStatement(self, obj): |
| '''Ignore''' |
| return True |
| |
| def visit_OptionStatement(self, obj): |
| if not hasattr(obj, 'mark_for_deletion'): |
| if (self.current_message_name): |
| self.message_options[obj.name.value.pval] = obj.value.value.pval |
| else: |
| self.options[obj.name.value.pval] = obj.value.value.pval |
| |
| return True |
| |
| def visit_LU(self, obj): |
| return True |
| |
| def visit_default(self, obj): |
| return True |
| |
| def visit_FieldDirective(self, obj): |
| return True |
| |
| def visit_FieldDirective_post(self, obj): |
| |
| try: |
| name = obj.name.value.pval |
| except AttributeError: |
| name = obj.name.value |
| |
| if type(obj.value) == list: |
| value = dotname_to_name(obj.value) |
| else: |
| value = name_to_value(obj) |
| |
| self.stack.push([name, value]) |
| return True |
| |
| def visit_FieldType(self, obj): |
| '''Field type, if type is name, then it may need refactoring consistent with refactoring rules according to the table''' |
| return True |
| |
| def visit_LinkDefinition(self, obj): |
| s = {} |
| |
| try: |
| s['link_type'] = obj.link_type.pval |
| except AttributeError: |
| s['link_type'] = obj.link_type |
| |
| s['src_port'] = obj.src_port.value.pval |
| s['name'] = obj.src_port.value.pval |
| try: |
| s['policy'] = obj.policy.pval |
| except AttributeError: |
| s['policy'] = None |
| |
| try: |
| s['dst_port'] = obj.dst_port.value.pval |
| except AttributeError: |
| s['dst_port'] = obj.dst_port |
| |
| if type(obj.through) == list: |
| s['through'] = dotname_to_fqn(obj.through) |
| else: |
| try: |
| s['through'] = obj.through.pval |
| except AttributeError: |
| s['through'] = obj.through |
| |
| if type(obj.name) == list: |
| s['peer'] = dotname_to_fqn(obj.name) |
| else: |
| try: |
| s['peer'] = obj.name.pval |
| except AttributeError: |
| s['peer'] = obj.name |
| |
| try: |
| s['reverse_id'] = obj.reverse_id.pval |
| except AttributeError: |
| s['reverse_id'] = obj.reverse_id |
| |
| s['_type'] = 'link' |
| s['options'] = {'modifier': 'optional'} |
| |
| self.stack.push(s) |
| return True |
| |
| def visit_FieldDefinition(self, obj): |
| self.count_stack.push(len(obj.fieldDirective)) |
| return True |
| |
| def visit_FieldDefinition_post(self, obj): |
| s = {} |
| |
| if isinstance(obj.ftype, m.Name): |
| s['type'] = obj.ftype.value |
| else: |
| s['type'] = obj.ftype.name.pval |
| |
| s['name'] = obj.name.value.pval |
| |
| try: |
| s['policy'] = obj.policy.pval |
| except AttributeError: |
| s['policy'] = None |
| |
| s['modifier'] = obj.field_modifier.pval |
| s['id'] = obj.fieldId.pval |
| |
| opts = {'modifier': s['modifier']} |
| n = self.count_stack.pop() |
| for i in range(0, n): |
| k, v = self.stack.pop() |
| |
| # The two lines below may be added to eliminate "" around an option. |
| # Right now, this is handled in targets. FIXME |
| # |
| # if (v.startswith('"') and v.endswith('"')): |
| # v = v[1:-1] |
| |
| opts[k] = v |
| |
| s['options'] = opts |
| try: |
| last_link = self.stack[-1]['_type'] |
| if (last_link == 'link'): |
| s['link'] = True |
| except: |
| pass |
| s['_type'] = 'field' |
| |
| self.stack.push(s) |
| return True |
| |
| def visit_EnumFieldDefinition(self, obj): |
| if self.verbose > 4: |
| print "\tEnumField: name=%s, %s" % (obj.name, obj) |
| |
| return True |
| |
| def visit_EnumDefinition(self, obj): |
| '''New enum definition, refactor name''' |
| if self.verbose > 3: |
| print "Enum, [%s] body=%s\n\n" % (obj.name, obj.body) |
| |
| return True |
| |
| def visit_MessageDefinition(self, obj): |
| self.current_message_name = obj.name.value.pval |
| self.message_options = {} |
| self.count_stack.push(count_fields(obj.body)) |
| return True |
| |
| def visit_MessageDefinition_post(self, obj): |
| stack_num = self.count_stack.pop() |
| fields = [] |
| links = [] |
| last_field = None |
| try: |
| obj.bases = map(dotname_to_fqn, obj.bases) |
| except AttributeError: |
| pass |
| |
| last_field = {} |
| for i in range(0, stack_num): |
| f = self.stack.pop() |
| if (f['_type'] == 'link'): |
| f['options'] = {i: d[i] for d in [f['options'], last_field['options']] for i in d} |
| assert (last_field == fields[0]) |
| fields[0].setdefault('options', {})['link_type'] = f['link_type'] |
| links.insert(0, f) |
| else: |
| fields.insert(0, f) |
| last_field = f |
| |
| if self.package: |
| model_name = '.'.join([self.package, obj.name.value.pval]) |
| else: |
| model_name = obj.name.value.pval |
| |
| model_def = {'name':obj.name.value.pval,'fields':fields,'links':links, 'bases':obj.bases, 'options':self.message_options, 'package':self.package, 'fqn': model_name, 'rlinks': []} |
| try: |
| model_def['policy'] = obj.policy.pval |
| except AttributeError: |
| model_def['policy'] = None |
| |
| self.stack.push(model_def) |
| |
| self.models[model_name] = model_def |
| |
| # Set message options |
| for k, v in self.options.iteritems(): |
| try: |
| if k not in self.message_options: |
| self.message_options[k] = v |
| except KeyError: |
| pass |
| |
| self.current_message_name = None |
| return True |
| |
| def visit_MessageExtension(self, obj): |
| return True |
| |
| def visit_MethodDefinition(self, obj): |
| return True |
| |
| def visit_ServiceDefinition(self, obj): |
| return True |
| |
| def visit_ExtensionsDirective(self, obj): |
| return True |
| |
| def visit_Literal(self, obj): |
| return True |
| |
| def visit_Name(self, obj): |
| return True |
| |
| def visit_DotName(self, obj): |
| return True |
| |
| def visit_Proto(self, obj): |
| self.count_stack.push(count_messages(obj.body)) |
| return True |
| |
| def visit_Proto_post(self, obj): |
| count = self.count_stack.pop() |
| messages = [] |
| for i in range(0, count): |
| try: |
| m = self.stack.pop() |
| except IndexError: |
| pass |
| |
| messages.insert(0, m) |
| |
| self.compute_rlinks(messages, self.models) |
| |
| self.messages = messages |
| return True |
| |
| def visit_LinkSpec(self, obj): |
| count = self.count_stack.pop() |
| self.count_stack.push(count + 1) |
| return True |
| |
| def compute_rlinks(self, messages, message_dict): |
| rev_links = {} |
| |
| link_opposite = { |
| 'manytomany': 'manytomany', |
| 'manytoone': 'onetomany', |
| 'onetoone': 'onetoone', |
| 'onetomany': 'manytoone' |
| } |
| |
| for m in messages: |
| for l in m['links']: |
| rlink = copy.deepcopy(l) |
| |
| rlink['_type'] = 'rlink' # An implicit link, not declared in the model |
| rlink['src_port'] = l['dst_port'] |
| rlink['dst_port'] = l['src_port'] |
| rlink['peer'] = {'name': m['name'], 'package': m['package'], 'fqn': m['fqn']} |
| rlink['link_type'] = link_opposite[l['link_type']] |
| rlink["reverse_id"] = l['reverse_id'] |
| |
| if (not l['reverse_id']) and (self.args.verbosity >= 1): |
| print >> sys.stderr, "WARNING: Field %s in model %s has no reverse_id" % (l["src_port"], m["name"]) |
| |
| if l["reverse_id"] and ((int(l["reverse_id"]) < 1000) or (int(l["reverse_id"]) >= 1900)): |
| raise Exception("reverse id for field %s in model %s should be between 1000 and 1899" % (l["src_port"], m["name"])) |
| |
| try: |
| try: |
| rev_links[l['peer']['fqn']].append(rlink) |
| except TypeError: |
| pass |
| except KeyError: |
| rev_links[l['peer']['fqn']] = [rlink] |
| |
| for m in messages: |
| try: |
| m['rlinks'] = rev_links[m['name']] |
| message_dict[m['name']]['rlinks'] = m['rlinks'] |
| except KeyError: |
| pass |