634 lines
22 KiB
Python
634 lines
22 KiB
Python
from collections import OrderedDict
|
|
from os.path import join, basename, dirname
|
|
from glob import glob
|
|
|
|
from tiramisu import StrOption, IntOption, BoolOption, ChoiceOption, OptionDescription, SymLinkOption, \
|
|
Config, Calculation, Params, ParamOption, ParamValue, calc_value, calc_value_property_help, \
|
|
groups, Option
|
|
|
|
from yaml import load, SafeLoader
|
|
from os import listdir
|
|
from os.path import isfile
|
|
from ..config import MESSAGE_ROOT_PATH
|
|
from ..utils import _
|
|
|
|
|
|
groups.addgroup('message')
|
|
|
|
|
|
class DictOption(Option):
|
|
__slots__ = tuple()
|
|
_type = 'dict'
|
|
_display_name = _('dict')
|
|
|
|
def validate(self, value):
|
|
if not isinstance(value, dict):
|
|
raise ValueError()
|
|
|
|
|
|
class AnyOption(Option):
|
|
__slots__ = tuple()
|
|
_type = 'any value'
|
|
_display_name = _('any')
|
|
|
|
def validate(self, value):
|
|
pass
|
|
|
|
|
|
class MessageDefinition:
|
|
"""
|
|
A MessageDefinition is a representation of a message in the Zephir application messaging context
|
|
"""
|
|
__slots__ = ('version',
|
|
'uri',
|
|
'description',
|
|
'sampleuse',
|
|
'domain',
|
|
'parameters',
|
|
'public',
|
|
'errors',
|
|
'pattern',
|
|
'related',
|
|
'response')
|
|
|
|
def __init__(self, raw_def):
|
|
# default value for non mandatory key
|
|
self.version = u''
|
|
self.parameters = OrderedDict()
|
|
self.public = False
|
|
self.errors = []
|
|
self.related = []
|
|
self.response = None
|
|
self.sampleuse = None
|
|
|
|
# loads yaml information into object
|
|
for key, value in raw_def.items():
|
|
if isinstance(value, str):
|
|
value = value.strip()
|
|
if key == 'public':
|
|
if not isinstance(value, bool):
|
|
raise ValueError(_("{} must be a boolean, not {}").format(key, value))
|
|
elif key == 'pattern':
|
|
if value not in ['rpc', 'event', 'error']:
|
|
raise Exception(_('unknown pattern {}').format(value))
|
|
elif key == 'parameters':
|
|
if 'type' in value and isinstance(value['type'], str):
|
|
# should be a customtype
|
|
value = customtypes[value['type']].properties
|
|
else:
|
|
value = _parse_parameters(value)
|
|
elif key == 'response':
|
|
value = ResponseDefinition(value)
|
|
elif key == 'errors':
|
|
value = _parse_error_definition(value)
|
|
setattr(self, key, value)
|
|
# check mandatory keys
|
|
for key in self.__slots__:
|
|
try:
|
|
getattr(self, key)
|
|
except AttributeError:
|
|
raise Exception(_('mandatory key not set {} message').format(key))
|
|
# message with pattern = error must be public
|
|
if self.public is False and self.pattern == 'error':
|
|
raise Exception(_('Error message must be public : {}').format(self.uri))
|
|
|
|
|
|
class ParameterDefinition:
|
|
__slots__ = ('name',
|
|
'type',
|
|
'description',
|
|
'help',
|
|
'default',
|
|
'ref',
|
|
'shortarg')
|
|
|
|
def __init__(self, name, raw_def):
|
|
self.name = name
|
|
# default value for non mandatory key
|
|
self.help = None
|
|
self.ref = None
|
|
self.shortarg = None
|
|
|
|
# loads yaml information into object
|
|
for key, value in raw_def.items():
|
|
if isinstance(value, str):
|
|
value = value.strip()
|
|
if key == 'type':
|
|
if value.startswith('[]'):
|
|
tvalue = value[2:]
|
|
else:
|
|
tvalue = value
|
|
if tvalue in customtypes:
|
|
if value.startswith('[]'):
|
|
value = '[]{}'.format(customtypes[tvalue].type)
|
|
else:
|
|
value = customtypes[value].type
|
|
else:
|
|
self._valid_type(value)
|
|
#self._valid_type(value)
|
|
setattr(self, key, value)
|
|
# check mandatory keys
|
|
for key in self.__slots__:
|
|
try:
|
|
getattr(self, key)
|
|
except AttributeError:
|
|
if key != 'default':
|
|
raise Exception(_('mandatory key not set "{}" in parameter').format(key))
|
|
|
|
def _valid_type(self, typ):
|
|
if typ.startswith('[]'):
|
|
self._valid_type(typ[2:])
|
|
elif typ not in ['Boolean', 'String', 'Number', 'File', 'Dict', 'Any']:
|
|
raise Exception(_('unknown parameter type: {}').format(typ))
|
|
|
|
class ResponseDefinition:
|
|
"""
|
|
An ResponseDefinition is a representation of a response in the Zephir application messaging context
|
|
"""
|
|
__slots__ = ('description',
|
|
'type',
|
|
'ref',
|
|
'parameters',
|
|
'required',
|
|
'multi')
|
|
|
|
def __init__(self, responses):
|
|
self.ref = None
|
|
self.parameters = None
|
|
self.multi = False
|
|
self.required = []
|
|
for key, value in responses.items():
|
|
if key in ['parameters', 'required']:
|
|
raise Exception(_('parameters and required must be set with a custom type'))
|
|
elif key == 'type':
|
|
if value.startswith('[]'):
|
|
tvalue = value[2:]
|
|
self.multi = True
|
|
else:
|
|
tvalue = value
|
|
if tvalue in customtypes:
|
|
self.parameters = customtypes[tvalue].properties
|
|
self.required = customtypes[tvalue].required
|
|
if value.startswith('[]'):
|
|
value = '[]{}'.format(customtypes[tvalue].type)
|
|
else:
|
|
value = customtypes[value].type
|
|
else:
|
|
self._valid_type(value)
|
|
setattr(self, key, value)
|
|
# check mandatory keys
|
|
for key in self.__slots__:
|
|
try:
|
|
getattr(self, key)
|
|
except AttributeError:
|
|
raise Exception(_('mandatory key not set {}').format(key))
|
|
|
|
def _valid_type(self, typ):
|
|
if typ.startswith('[]'):
|
|
self._valid_type(typ[2:])
|
|
elif typ not in ['Boolean', 'String', 'Number', 'File', 'Dict']:
|
|
raise Exception(_('unknown parameter type: {}').format(typ))
|
|
|
|
|
|
class ErrorDefinition:
|
|
"""
|
|
An ErrorDefinition is a representation of an error in the Zephir application messaging context
|
|
"""
|
|
__slots__ = ('uri',)
|
|
|
|
def __init__(self, raw_err):
|
|
extra_keys = set(raw_err) - set(self.__slots__)
|
|
if extra_keys:
|
|
raise Exception(_('extra keys for errors: {}').format(extra_keys))
|
|
self.uri = raw_err['uri']
|
|
|
|
|
|
def _parse_error_definition(raw_defs):
|
|
new_value = []
|
|
for raw_err in raw_defs:
|
|
new_value.append(ErrorDefinition(raw_err))
|
|
return new_value
|
|
|
|
|
|
def _parse_parameters(raw_defs):
|
|
parameters = OrderedDict()
|
|
for name, raw_def in raw_defs.items():
|
|
parameters[name] = ParameterDefinition(name, raw_def)
|
|
return parameters
|
|
|
|
|
|
def parse_definition(filename: str):
|
|
return MessageDefinition(load(filename, Loader=SafeLoader))
|
|
|
|
def is_message_defined(uri):
|
|
version, message = split_message_uri(uri)
|
|
path = get_message_file_path(version, message)
|
|
return isfile(path)
|
|
|
|
def get_message(uri):
|
|
load_customtypes()
|
|
try:
|
|
version, message = split_message_uri(uri)
|
|
path = get_message_file_path(version, message)
|
|
with open(path, "r") as message_file:
|
|
message_content = parse_definition(message_file.read())
|
|
message_content.version = version
|
|
return message_content
|
|
except Exception as err:
|
|
import traceback
|
|
traceback.print_exc()
|
|
raise Exception(_('cannot parse message {}: {}').format(uri, str(err)))
|
|
|
|
def split_message_uri(uri):
|
|
return uri.split('.', 1)
|
|
|
|
def get_message_file_path(version, message):
|
|
return join(MESSAGE_ROOT_PATH, version, 'messages', message + '.yml')
|
|
|
|
def list_messages():
|
|
messages = listdir(MESSAGE_ROOT_PATH)
|
|
messages.sort()
|
|
for version in messages:
|
|
for message in listdir(join(MESSAGE_ROOT_PATH, version, 'messages')):
|
|
if message.endswith('.yml'):
|
|
yield version + '.' + message.rsplit('.', 1)[0]
|
|
|
|
class CustomParam:
|
|
__slots__ = ('name',
|
|
'type',
|
|
'description',
|
|
'ref',
|
|
'default')
|
|
|
|
def __init__(self, name, raw_def, required):
|
|
self.name = name
|
|
self.ref = None
|
|
if name not in required:
|
|
self.default = None
|
|
|
|
# loads yaml information into object
|
|
for key, value in raw_def.items():
|
|
if isinstance(value, str):
|
|
value = value.strip()
|
|
if key == 'type':
|
|
value = self._convert_type(value, raw_def)
|
|
elif key == 'items':
|
|
continue
|
|
setattr(self, key, value)
|
|
|
|
# check mandatory keys
|
|
for key in self.__slots__:
|
|
try:
|
|
getattr(self, key)
|
|
except AttributeError:
|
|
# default value for non mandatory key
|
|
if key != 'default':
|
|
raise Exception(_('mandatory key not set "{}" in parameter').format(key))
|
|
|
|
def _convert_type(self, typ, raw_def):
|
|
types = {'boolean': 'Boolean',
|
|
'string': 'String',
|
|
'number': 'Number',
|
|
'object': 'Dict',
|
|
'array': 'Array',
|
|
'file': 'File'}
|
|
|
|
if typ not in list(types.keys()):
|
|
# validate after
|
|
return typ
|
|
if typ == 'array' and 'items' in raw_def:
|
|
if not isinstance(raw_def['items'], dict):
|
|
raise Exception(_('items must be a dict'))
|
|
if list(raw_def['items'].keys()) != ['type']:
|
|
raise Exception(_('items must be a dict with only a type'))
|
|
return '[]{}'.format(self._convert_type(raw_def['items']['type'], raw_def))
|
|
return types[typ]
|
|
|
|
|
|
def _parse_custom_params(raw_defs, required):
|
|
parameters = OrderedDict()
|
|
for name, raw_def in raw_defs.items():
|
|
parameters[name] = CustomParam(name, raw_def, required)
|
|
return parameters
|
|
|
|
|
|
class CustomType:
|
|
__slots__ = ('title',
|
|
'type',
|
|
'description',
|
|
'ref',
|
|
'properties',
|
|
'required')
|
|
|
|
def __init__(self, raw_def):
|
|
# default value for non mandatory key
|
|
self.ref = None
|
|
|
|
# loads yaml information into object
|
|
for key, value in raw_def.items():
|
|
if isinstance(value, str):
|
|
value = value.strip()
|
|
if key == 'type':
|
|
value = self._convert_type(value, raw_def)
|
|
elif key == 'properties':
|
|
value = _parse_custom_params(value, raw_def.get('required', {}))
|
|
|
|
setattr(self, key, value)
|
|
# check mandatory keys
|
|
for key in self.__slots__:
|
|
try:
|
|
getattr(self, key)
|
|
except AttributeError:
|
|
raise Exception(_('mandatory key not set "{}" in parameter').format(key))
|
|
|
|
def _convert_type(self, typ, raw_def):
|
|
types = {'boolean': 'Boolean',
|
|
'string': 'String',
|
|
'number': 'Number',
|
|
'object': 'Dict',
|
|
'array': 'Array'}
|
|
|
|
if typ not in list(types.keys()):
|
|
# validate after
|
|
return typ
|
|
if typ == 'array' and 'items' in raw_def:
|
|
if not isinstance(raw_def['items'], dict):
|
|
raise Exception(_('items must be a dict'))
|
|
if list(raw_def['items'].keys()) != ['type']:
|
|
raise Exception(_('items must be a dict with only a type'))
|
|
return '[]{}'.format(self._convert_type(raw_def['items']['type'], raw_def))
|
|
return types[typ]
|
|
|
|
def getname(self):
|
|
return self.title
|
|
|
|
|
|
customtypes = {}
|
|
def load_customtypes():
|
|
if not customtypes:
|
|
versions = listdir(MESSAGE_ROOT_PATH)
|
|
versions.sort()
|
|
for version in versions:
|
|
for message in listdir(join(MESSAGE_ROOT_PATH, version, 'types')):
|
|
if message.endswith('.yml'):
|
|
path = join(MESSAGE_ROOT_PATH, version, 'types', message)
|
|
message = message.rsplit('.', 1)[0]
|
|
with open(path, "r") as message_file:
|
|
try:
|
|
ret = CustomType(load(message_file, Loader=SafeLoader))
|
|
customtypes[ret.getname()] = ret
|
|
except Exception as err:
|
|
import traceback
|
|
traceback.print_exc()
|
|
raise Exception('{} for {}'.format(err, message))
|
|
for customtype in customtypes.values():
|
|
properties = {}
|
|
for key, value in customtype.properties.items():
|
|
type_ = value.type
|
|
if type_.startswith('[]'):
|
|
ttype_ = type_[2:]
|
|
else:
|
|
ttype_ = type_
|
|
if ttype_ in customtypes:
|
|
if type_.startswith('[]'):
|
|
raise Exception(_('cannot have []CustomType'))
|
|
properties[key] = customtypes[ttype_]
|
|
else:
|
|
properties[key] = value
|
|
customtype.properties = properties
|
|
|
|
|
|
def _get_description(description,
|
|
name):
|
|
# hack because some description are, in fact some help
|
|
if not '\n' in description and len(description) <= 150:
|
|
doc = description
|
|
else:
|
|
doc = name
|
|
if doc.endswith('.'):
|
|
doc= description[:-1]
|
|
return doc
|
|
|
|
|
|
def _get_option(name,
|
|
arg,
|
|
file_path,
|
|
select_option,
|
|
optiondescription):
|
|
"""generate option
|
|
"""
|
|
props = []
|
|
if not hasattr(arg, 'default'):
|
|
props.append('mandatory')
|
|
props.append(Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(select_option, todict=True),
|
|
'expected': ParamValue(optiondescription),
|
|
'reverse_condition': ParamValue(True)}),
|
|
calc_value_property_help))
|
|
|
|
description = arg.description.strip().rstrip()
|
|
kwargs = {'name': name,
|
|
'doc': _get_description(description, name),
|
|
'properties': frozenset(props),
|
|
#'multi': arg.multi,
|
|
}
|
|
if hasattr(arg, 'default'):
|
|
kwargs['default'] = arg.default
|
|
type_ = arg.type
|
|
if type_.startswith('[]'):
|
|
kwargs['multi'] = True
|
|
type_ = type_[2:]
|
|
if type_ == 'Dict':
|
|
return DictOption(**kwargs)
|
|
elif type_ == 'String':
|
|
return StrOption(**kwargs)
|
|
elif type_ == 'Any':
|
|
return AnyOption(**kwargs)
|
|
elif 'Number' in type_ or type_ == 'ID' or type_ == 'Integer':
|
|
return IntOption(**kwargs)
|
|
elif type_ == 'Boolean':
|
|
return BoolOption(**kwargs)
|
|
raise Exception('unsupported type {} in {}'.format(type_, file_path))
|
|
|
|
|
|
def _parse_args(message_def,
|
|
options,
|
|
file_path,
|
|
needs,
|
|
select_option,
|
|
optiondescription,
|
|
load_shortarg):
|
|
"""build option with args/kwargs
|
|
"""
|
|
new_options = OrderedDict()
|
|
for name, arg in message_def.parameters.items():
|
|
new_options[name] = arg
|
|
if arg.ref:
|
|
needs.setdefault(message_def.uri, {}).setdefault(arg.ref, []).append(name)
|
|
for name, arg in new_options.items():
|
|
current_opt = _get_option(name, arg, file_path, select_option, optiondescription)
|
|
options.append(current_opt)
|
|
if hasattr(arg, 'shortarg') and arg.shortarg and load_shortarg:
|
|
options.append(SymLinkOption(arg.shortarg, current_opt))
|
|
|
|
|
|
def _parse_responses(message_def,
|
|
file_path):
|
|
"""build option with returns
|
|
"""
|
|
if message_def.response.parameters is None:
|
|
raise Exception('not implemented yet')
|
|
#name = 'response'
|
|
#keys['']['columns'][name] = {'description': message_def.response.description,
|
|
# 'type': message_def.response.type}
|
|
#responses = {}
|
|
#responses['keys'] = keys
|
|
#return responses
|
|
|
|
options = []
|
|
names = []
|
|
for name, obj in message_def.response.parameters.items():
|
|
if name in names:
|
|
raise Exception('multi response with name {} in {}'.format(name, file_path))
|
|
names.append(name)
|
|
|
|
kwargs = {'name': name,
|
|
'doc': obj.description.strip().rstrip()}
|
|
type_ = obj.type
|
|
if type_.startswith('[]'):
|
|
kwargs['multi'] = True
|
|
type_ = type_[2:]
|
|
option = {'String': StrOption,
|
|
'Number': IntOption,
|
|
'Boolean': BoolOption,
|
|
'Dict': DictOption,
|
|
# FIXME
|
|
'File': StrOption}.get(type_)
|
|
if not option:
|
|
raise Exception(f'unknown param type {obj.type}')
|
|
if hasattr(obj, 'default'):
|
|
kwargs['default'] = obj.default
|
|
else:
|
|
kwargs['properties'] = ('mandatory',)
|
|
options.append(option(**kwargs))
|
|
od = OptionDescription(message_def.uri,
|
|
message_def.response.description,
|
|
options)
|
|
od.impl_set_information('multi', message_def.response.multi)
|
|
return od
|
|
|
|
|
|
def _getoptions_from_yml(message_def,
|
|
version,
|
|
optiondescriptions,
|
|
file_path,
|
|
needs,
|
|
select_option,
|
|
load_shortarg):
|
|
if message_def.pattern == 'event' and message_def.response:
|
|
raise Exception('event with response?: {}'.format(file_path))
|
|
if message_def.pattern == 'rpc' and not message_def.response:
|
|
print('rpc without response?: {}'.format(file_path))
|
|
options = []
|
|
# options = [StrOption('version',
|
|
# 'version',
|
|
# version,
|
|
# properties=frozenset(['hidden']))]
|
|
_parse_args(message_def, options, file_path, needs, select_option, message_def.uri, load_shortarg)
|
|
name = message_def.uri
|
|
description = message_def.description.strip().rstrip()
|
|
optiondescriptions[name] = (description, options)
|
|
|
|
|
|
def _get_root_option(select_option, optiondescriptions):
|
|
"""get root option
|
|
"""
|
|
def _get_od(curr_ods):
|
|
options = []
|
|
for name in curr_ods.keys():
|
|
if name is None:
|
|
description, curr_options = curr_ods[name]
|
|
options.extend(curr_ods[name][1])
|
|
else:
|
|
if None in curr_ods[name].keys():
|
|
description = curr_ods[name][None][0]
|
|
if description.endswith('.'):
|
|
description = description[:-1]
|
|
else:
|
|
description = None
|
|
od = OptionDescription(name,
|
|
description,
|
|
_get_od(curr_ods[name]))
|
|
if None in list(curr_ods[name].keys()):
|
|
od.impl_set_group_type(groups.message)
|
|
options.append(od)
|
|
return options
|
|
|
|
options_obj = [select_option]
|
|
struct_od = {}
|
|
for od_name, options_descr in optiondescriptions.items():
|
|
# od_name is something like config.configuration.server.get
|
|
curr_od = struct_od
|
|
for subod in od_name.split('.'):
|
|
curr_od.setdefault(subod, {})
|
|
curr_od = curr_od[subod]
|
|
# curr_od is now {'config': {'configuration': {server: {}}}}
|
|
curr_od[None] = options_descr
|
|
# curr_od is now {'config': {'configuration': {server: {None: options_descr}}}}
|
|
options_obj.extend(_get_od(struct_od))
|
|
return OptionDescription('root', 'root', options_obj)
|
|
|
|
|
|
def get_messages(load_shortarg=False, only_public=False):
|
|
"""generate description from yml files
|
|
"""
|
|
optiondescriptions = OrderedDict()
|
|
optiondescriptions_name = []
|
|
optiondescriptions_info = {}
|
|
needs = OrderedDict()
|
|
messages = list(list_messages())
|
|
messages.sort()
|
|
for message_name in messages:
|
|
message_def = get_message(message_name)
|
|
if message_def.pattern not in ['rpc', 'event'] or \
|
|
(not message_def.public and only_public):
|
|
continue
|
|
optiondescriptions_name.append(message_def.uri)
|
|
optiondescriptions_name.sort()
|
|
select_option = ChoiceOption('message',
|
|
'Nom du message.',
|
|
tuple(optiondescriptions_name),
|
|
properties=frozenset(['mandatory', 'positional']))
|
|
for message_name in messages:
|
|
message_def = get_message(message_name)
|
|
if message_def.pattern not in ['rpc', 'event'] or \
|
|
(not message_def.public and only_public):
|
|
continue
|
|
optiondescriptions_info[message_def.uri] = {'pattern': message_def.pattern,
|
|
'public': message_def.public}
|
|
if message_def.pattern == 'rpc':
|
|
optiondescriptions_info[message_def.uri]['response'] = _parse_responses(message_def,
|
|
message_name)
|
|
elif message_def.response:
|
|
raise Exception(f'response not allowed for {message_def.uri}')
|
|
version = message_name.split('.')[0]
|
|
_getoptions_from_yml(message_def,
|
|
version,
|
|
optiondescriptions,
|
|
message_name,
|
|
needs,
|
|
select_option,
|
|
load_shortarg)
|
|
|
|
root = _get_root_option(select_option, optiondescriptions)
|
|
try:
|
|
config = Config(root)
|
|
except Exception as err:
|
|
raise Exception('error when generating root optiondescription: {}'.format(err))
|
|
|
|
config.property.read_write()
|
|
# config.property.add('demoting_error_warning')
|
|
# return needs, responses, config
|
|
return optiondescriptions_info, root
|