def parse(self, filename):
"""Parse XML.
Returns an instance of model.Interface containing parsed
interface or raises ParseError if input XML contains errors
and can't be parsed.
:param filename: name of input XML file.
:return: Interface object
"""
tree = ElementTree.parse(filename)
root = tree.getroot()
self._enums = self._initialize_enums()
self._structs = OrderedDict()
self._functions = OrderedDict()
self._params = {}
self._types = dict(self._enums.items())
self._parse_root(root)
return Interface(enums=self._enums,
structs=self._structs,
functions=self._functions,
params=self._params)
def filter_pattern(self, interface, pattern):
"""
:param interface: initial Model
:param pattern: regex-pattern from command-line arguments to filter element from initial Model
:return: initial Model
"""
names = tuple(interface.enums.keys()) + tuple(interface.structs.keys())
if pattern:
match = {i: OrderedDict() for i in vars(interface).keys()}
match['params'] = interface.params
empty = True
for key, value in vars(interface).items():
if key == 'params':
continue
for name, item in value.items():
if re.match(pattern, item.name):
if hasattr(item, 'message_type'):
log = '{}/{} {} match with {}'.format(
key, item.name, item.message_type.name.title(),
pattern)
else:
log = '{}/{} match with {}'.format(
key, item.name, pattern)
self.logger.info(log)
if key in match:
match[key][name] = item
empty = False
if empty:
self.logger.warning('no one match with %s', pattern)
sys.exit(0)
return Interface(**match), names
return interface, names
def get_interfaces(*conditions):
interfaces = list()
response = super(InterfaceOperations, InterfaceOperations).get(
constants.OVSDBTables.interface.value, *conditions)
for record in response:
interfaces.append(
Interface(
record['name'],
admin_state=record['admin_state'],
bfd={key: value
for key, value in record['bfd'][1]},
bfd_status={
key: value
for key, value in record['bfd_status'][1]
},
cfm_fault=record['cfm_fault'][1],
cfm_fault_status=record['cfm_fault_status'][1],
cfm_flap_count=record['cfm_flap_count'][1],
cfm_health=record['cfm_health'][1],
cfm_mpid=record['cfm_mpid'][1],
cfm_remote_mpids=record['cfm_remote_mpids'][1],
cfm_remote_opstate=record['cfm_remote_opstate'][1],
duplex=record['duplex'][1],
error=record['error'][1],
external_ids={
key: value
for key, value in record['external_ids'][1]
},
ifindex=record['ifindex'],
ingress_policing_burst=record['ingress_policing_burst'],
ingress_policing_rate=record['ingress_policing_rate'],
lacp_current=record['lacp_current'][1],
link_resets=record['link_resets'],
link_speed=record['link_speed'][1],
link_state=record['link_state'],
lldp={key: value
for key, value in record['lldp'][1]},
mac=record['mac'][1],
mac_in_use=record['mac_in_use'],
mtu=record['mtu'],
mtu_request=record['mtu_request'][1],
ofport=record['ofport'],
ofport_request=record['ofport_request'][1],
options={
key: value
for key, value in record['options'][1]
},
other_config={
key: value
for key, value in record['other_config'][1]
},
statistics={
key: value
for key, value in record['statistics'][1]
},
status={key: value
for key, value in record['status'][1]},
type=record['type'],
uuid=record['_uuid'][1]))
return interfaces
def parser(self, xml, xsd, pattern=None):
"""
Validate xml to match with xsd. Calling parsers to get Model from xml. If provided pattern, filtering Model.
:param xml: path to MOBILE_API.xml
:param xsd: path to MOBILE_API.xsd
:param pattern: regex-pattern from command-line arguments to filter element from initial Model
:return: initial Model
"""
self.logger.info(
'''Validating XML and generating model with following parameters:
Source xml : %s
Source xsd : %s''', xml, xsd)
try:
schema = XMLSchema(xsd)
if not schema.is_valid(xml):
raise GenerateError(schema.validate(xml))
interface = Parser().parse(xml)
except (InterfaceError, XMLSchemaError, GenerateError) as message1:
self.logger.critical('Invalid XML file content: %s, %s', xml,
message1)
sys.exit(1)
enum_names = tuple(interface.enums.keys())
struct_names = tuple(interface.structs.keys())
if pattern:
intermediate = OrderedDict()
intermediate.update({'params': interface.params})
for kind, content in vars(interface).items():
if kind == 'params':
continue
for name, item in content.items():
if re.match(pattern, item.name):
self.logger.info('%s/%s match with %s', kind,
item.name, pattern)
if kind in intermediate:
intermediate[kind].update({name: item})
else:
intermediate.update({kind: {name: item}})
interface = Interface(**intermediate)
self.logger.debug({
'enums':
tuple(interface.enums.keys()),
'structs':
tuple(interface.structs.keys()),
'functions':
tuple(
map(lambda i: i.function_id.name,
interface.functions.values())),
'params':
interface.params
})
return enum_names, struct_names, interface
def filter_pattern(interface, pattern):
"""
Filtering Model to match with regex pattern
:param interface: Initial (original) Model, obtained from module 'rpc_spec/InterfaceParser'
:param pattern: regex pattern (string)
:return: Model with items which match with regex pattern
"""
enum_names = tuple(interface.enums.keys())
struct_names = tuple(interface.structs.keys())
if pattern:
match = {key: OrderedDict() for key in vars(interface).keys()}
match['params'] = interface.params
for key, value in vars(interface).items():
if key == 'params':
continue
match[key].update({name: item for name, item in value.items() if re.match(pattern, item.name)})
return Interface(**match), enum_names, struct_names
return interface, enum_names, struct_names
def filter_pattern(interface, pattern):
"""
Filtring model according to regex pattern
:param interface: Interface model
:param pattern: regex pattern
:return:
"""
match = {i: {} for i in vars(interface).keys()}
match['params'] = interface.params
if pattern:
for key, value in vars(interface).items():
if key == 'params':
continue
for name, item in value.items():
if re.match(pattern, item.name):
if key in match:
match[key].update({name: item})
else:
return interface
return Interface(**match)
def from_tree(cls, ctx: VhdlParser.Port_clauseContext):
port_list = cls()
interface_port_list = ctx.port_list().interface_port_list()
for declaration in interface_port_list.interface_port_declaration():
direction = declaration.signal_mode().getText()
data_type = declaration.subtype_indication()
data_type = DataType.from_tree(data_type)
value = declaration.expression()
if value is not None:
value = value.getText()
for identifier in declaration.identifier_list().identifier():
name = identifier.getText()
interface = Interface(name, data_type, value)
port = Port(direction, interface)
port_list.append(port)
return port_list
def test_full_generation(self):
"""Test full generation using SDLPRC SmartSchema generator.
Creates output files which is captured by the mock and compare them
with sample files with correct code. This test requires valid
test_expected_sdlrpc.h and test_expected_sdlrpc.cc in the same as
this module.
"""
self.maxDiff = None
expected_h_file_content = Path(__file__).parents[0].joinpath('test_expected_sdlrpc.h').read_text()
expected_cc_file_content = Path(__file__).parents[0].joinpath('test_expected_sdlrpc.cc').read_text()
generator = SmartFactorySDLRPC.CodeGenerator()
message_type_elements = collections.OrderedDict()
message_type_elements[u"request"] = EnumElement(name=u"request")
message_type_elements[u"response"] = EnumElement(
name=u"response")
message_type_elements[u"notification"] = EnumElement(
name=u"notification")
message_type = Enum(name=u"messageType",
elements=message_type_elements)
elements1 = collections.OrderedDict()
elements1[u"name1"] = EnumElement(
name=u"name1",
design_description=DESIGN_DESCRIPTION,
todos=TODOS,
value=u"1")
elements1[u"name2"] = EnumElement(
name="name2",
description=DESCRIPTION,
issues=ISSUES,
internal_name=u"internal_name2")
enum1 = Enum(name=u"Enum1",
todos=TODOS,
elements=elements1)
elements2 = collections.OrderedDict()
elements2[u"xxx"] = EnumElement(name=u"xxx",
internal_name=u"val_1")
elements2[u"yyy"] = EnumElement(name=u"yyy",
internal_name=u"val_2",
value=u"100")
elements2[u"zzz"] = EnumElement(name=u"val_3")
enum2 = Enum(name=u"E2",
elements=elements2)
elements3 = collections.OrderedDict()
elements3["1"] = EnumElement(name="xxx",
internal_name="_1")
elements3["2"] = EnumElement(name="xxx",
internal_name="_2")
elements3["3"] = EnumElement(name="xxx",
internal_name="_3")
enum3 = Enum(name="Enum_new2",
elements=elements3)
elements4 = collections.OrderedDict()
elements4["name1"] = EnumElement(name="xxx",
internal_name="_11")
elements4["name2"] = EnumElement(name="xxx",
internal_name="_22")
enum4 = Enum(name="Enum_new4",
elements=elements4)
enums = collections.OrderedDict()
enums["Enum1"] = enum1
enums["Enum2"] = enum2
enums["Enum3"] = enum3
enums["Enum4"] = enum4
enums["messageType"] = message_type
params1 = collections.OrderedDict()
params1["1"] = Param(
name="param1",
design_description=DESIGN_DESCRIPTION,
description=DESCRIPTION,
issues=ISSUES,
todos=TODOS,
param_type=enum4,
default_value=elements4["name1"])
params1["2"] = Param(
name="param2",
param_type=EnumSubset(
name="sub1",
enum=enum1,
allowed_elements={"e1": elements1["name1"]}),
default_value=elements1["name1"])
functions = collections.OrderedDict()
functions["Function1"] = Function(
name="Function1",
function_id=elements1["name1"],
message_type=message_type_elements["request"],
params=params1)
functions["Function2"] = Function(
name="Function2",
function_id=elements2["xxx"],
message_type=message_type_elements["response"])
functions["Function3"] = Function(
name="Function2",
function_id=elements2["yyy"],
message_type=message_type_elements["notification"])
members1 = collections.OrderedDict()
members1["m1"] = Param(name="intParam",
param_type=Integer(max_value=2))
members1["m11"] = Param(name="doubleParam",
param_type=Float(min_value=0.333),
is_mandatory=False)
members1["m222"] = Param(name="boolParam",
param_type=Boolean())
members1["m2"] = Param(name="structParam",
param_type=Struct(name="Struct2"))
members1["aaa"] = Param(name="enumParam",
param_type=enum1)
members1["bbb"] = Param(name="enumParam1",
param_type=enum1)
members1["xxx"] = Param(
name="enumSubset1",
param_type=EnumSubset(
name="sub",
enum=enum1,
allowed_elements={"e1": elements1["name1"]}),
is_mandatory=False)
members1["1"] = Param(
name="arrayOfInt",
param_type=Array(min_size=0,
max_size=20,
element_type=Boolean()),
is_mandatory=False)
members1["2"] = Param(
name="arrayOfEnum1",
param_type=Array(min_size=0,
max_size=20,
element_type=enum1),
is_mandatory=False)
members1["3"] = Param(
name="arrayOfEnum3",
param_type=Array(min_size=10,
max_size=40,
element_type=enum3),
is_mandatory=True)
members1["4"] = Param(
name="arrayOfEnum4",
param_type=Array(
min_size=10,
max_size=41,
element_type=EnumSubset(
name="sub1",
enum=enum1,
allowed_elements={"e1": elements1["name1"]})))
members1["5"] = Param(
name="arrayOfEnum5",
param_type=Array(
min_size=10,
max_size=42,
element_type=EnumSubset(
name="sub2",
enum=enum1,
allowed_elements={"e1": elements1["name2"]})))
members1["6"] = Param(
name="arrayOfEnum6",
param_type=Array(
min_size=10,
max_size=43,
element_type=EnumSubset(
name="sub3",
enum=enum4,
allowed_elements={"e1": elements4["name2"]})))
structs = collections.OrderedDict()
structs["Struct1"] = Struct(
name="Struct1",
design_description=DESIGN_DESCRIPTION,
issues=ISSUES,
members=members1)
structs["Struct2"] = Struct(name="Struct2",
issues=ISSUES)
interface = Interface(enums=enums,
structs=structs,
functions=functions,
params={"param1": "value1",
"param2": "value2"})
os.path.exists = MagicMock(return_value=True)
uuid.uuid1 = MagicMock(
return_value=uuid.UUID("12345678123456781234567812345678"))
codecs.open = MagicMock()
generator.generate(interface=interface,
filename="Test.xml",
namespace="XXX::YYY::ZZZ",
destination_dir="/some/test/dir")
os.path.exists.assert_has_calls([call('/some/test/dir')])
open_result = codecs.open
mock_calls = open_result.mock_calls
self.assertEqual(mock_calls[0],
call('/some/test/dir/Test.h',
mode='w',
encoding='utf-8'),
"Invalid header file creation")
self.assertEqual(mock_calls[4],
call('/some/test/dir/Test_schema.h',
mode='w',
encoding='utf-8'),
"Invalid source file creation")
try:
self.assertSequenceEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"),
expected_h_file_content,
"Invalid header file content")
self.assertSequenceEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"),
expected_cc_file_content,
"Invalid source file content")
except AssertionError as message:
print(message)