|
|
# vim: fileencoding=utf-8
|
|
|
#
|
|
|
from .base_format import Format
|
|
|
from collections import OrderedDict
|
|
|
from pyparsing import originalTextFor, Literal, Word, printables, OneOrMore,\
|
|
|
alphanums, ParseException, restOfLine, nums,\
|
|
|
delimitedList, Optional, Keyword, SkipTo, Group, Regex
|
|
|
|
|
|
|
|
|
class LDAPFormat(Format):
|
|
|
FORMAT = 'ldap'
|
|
|
EXECUTABLE = False
|
|
|
|
|
|
_initialized = False
|
|
|
|
|
|
comment_symbol = '#'
|
|
|
|
|
|
def __new__(cls, *args, **kwargs):
|
|
|
if not cls._initialized:
|
|
|
cls._initialize_parser()
|
|
|
return super().__new__(cls)
|
|
|
|
|
|
def __init__(self, document_text: str,
|
|
|
template_path,
|
|
|
ignore_comments=False,
|
|
|
join_before=False,
|
|
|
add_header=False,
|
|
|
already_changed=False,
|
|
|
**kwargs):
|
|
|
processing_methods = [self._parse_comment_line,
|
|
|
self._parse_type_line,
|
|
|
self._parse_access_line,
|
|
|
self._parse_access_line_to_delete,
|
|
|
self._parse_syncrepl_line,
|
|
|
self._parse_syncrepl_line_to_delete,
|
|
|
self._parse_notunique_line,
|
|
|
self._parse_index_line,
|
|
|
self._parse_index_line_to_delete,
|
|
|
self._parse_plain_directive_line,
|
|
|
self._parse_plain_directive_line_to_delete]
|
|
|
|
|
|
super().__init__(processing_methods)
|
|
|
self._ignore_comments = ignore_comments
|
|
|
self._comments_processing = True
|
|
|
self._join_before = join_before
|
|
|
self._need_finish = True
|
|
|
|
|
|
if self._ignore_comments:
|
|
|
self._current_type_section = OrderedDict()
|
|
|
else:
|
|
|
self._current_type_section = OrderedDict({'#': []})
|
|
|
|
|
|
self._current_type = ('', 'global')
|
|
|
|
|
|
self._last_comments_list = []
|
|
|
|
|
|
if add_header and not ignore_comments:
|
|
|
self.header, document_text = self._get_header_and_document_text(
|
|
|
document_text,
|
|
|
template_path,
|
|
|
already_changed=already_changed)
|
|
|
else:
|
|
|
self.header = ''
|
|
|
|
|
|
document_text = document_text.strip()
|
|
|
if document_text == '':
|
|
|
self._document_dictionary = OrderedDict()
|
|
|
else:
|
|
|
document_lines = self._get_list_of_logic_lines(document_text)
|
|
|
self._lines_to_dictionary(document_lines)
|
|
|
|
|
|
@classmethod
|
|
|
def _initialize_parser(cls):
|
|
|
'''Метод для инициализации парсеров.'''
|
|
|
cls._comment_line = originalTextFor(
|
|
|
Literal(cls.comment_symbol)
|
|
|
+ Regex(r'.*'))('comment')
|
|
|
|
|
|
action_symbols = (Literal('!') | Literal('-'))
|
|
|
assignment = Literal('=')
|
|
|
|
|
|
# Для парсинга строк c директивами неуникальными для секции.
|
|
|
not_unique_directives = originalTextFor(
|
|
|
Keyword('include') |
|
|
|
Keyword('moduleload')
|
|
|
)
|
|
|
|
|
|
not_unique_value = originalTextFor(
|
|
|
OneOrMore(Word(printables))
|
|
|
)('value')
|
|
|
|
|
|
cls._not_unique_parser = (Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ not_unique_directives
|
|
|
+ not_unique_value + restOfLine.suppress())
|
|
|
|
|
|
# Для выделения областей global, backend и database.
|
|
|
type_sections_keywords = originalTextFor(
|
|
|
Keyword('backend') |
|
|
|
Keyword('database')
|
|
|
)
|
|
|
|
|
|
type_value = originalTextFor(Word(alphanums))
|
|
|
|
|
|
cls._type_line = (Optional(action_symbols, default='')('action')
|
|
|
+ type_sections_keywords
|
|
|
+ type_value
|
|
|
+ restOfLine.suppress())
|
|
|
|
|
|
# Для парсинга конструкции syncrepl rid=<replica ID> <parameters>
|
|
|
content_without_spaces = Word(printables, excludeChars='"')
|
|
|
|
|
|
content_with_spaces = (Literal('"')
|
|
|
+ OneOrMore(Word(printables,
|
|
|
excludeChars='"'))
|
|
|
+ Literal('"'))
|
|
|
|
|
|
parameter_without_spaces = (Word(printables, excludeChars='"=')
|
|
|
+ assignment.suppress()
|
|
|
+ content_without_spaces)
|
|
|
|
|
|
parameter_with_spaces = (Word(printables, excludeChars='"=')
|
|
|
+ assignment.suppress()
|
|
|
+ content_with_spaces)
|
|
|
|
|
|
values = OneOrMore(originalTextFor(parameter_with_spaces |
|
|
|
parameter_without_spaces))('Values')
|
|
|
|
|
|
syncrepl_replica_id = originalTextFor(Literal('rid')
|
|
|
+ assignment.suppress()
|
|
|
+ Word(nums))('replicaID')
|
|
|
|
|
|
cls._syncrepl_line_parser = (Group(Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ Keyword('syncrepl')
|
|
|
+ syncrepl_replica_id)('name')
|
|
|
+ values('Values')
|
|
|
+ restOfLine.suppress())
|
|
|
|
|
|
cls._syncrepl_value_parser = (Group(Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ originalTextFor(
|
|
|
Word(
|
|
|
printables,
|
|
|
excludeChars='"='
|
|
|
)
|
|
|
))('name')
|
|
|
+ assignment.suppress()
|
|
|
+ originalTextFor(
|
|
|
OneOrMore(
|
|
|
Word(printables)
|
|
|
)
|
|
|
)('value'))
|
|
|
|
|
|
cls._syncrepl_line_to_delete_parser = (Group(Optional(
|
|
|
action_symbols,
|
|
|
default=''
|
|
|
)('action')
|
|
|
+ Keyword('syncrepl')
|
|
|
+ syncrepl_replica_id)('name')
|
|
|
+ restOfLine.suppress())
|
|
|
|
|
|
# Для парсинга конструкции
|
|
|
# access to <what> by <who>|<access level>|<control>
|
|
|
access_keyword = originalTextFor(Literal('access to'))('keyword')
|
|
|
|
|
|
value = originalTextFor(parameter_with_spaces |
|
|
|
parameter_without_spaces |
|
|
|
content_without_spaces |
|
|
|
content_with_spaces)
|
|
|
|
|
|
cls._access_line_parser = (Group(Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ access_keyword
|
|
|
+ value)('name')
|
|
|
+ Keyword('by').suppress()
|
|
|
+ delimitedList(
|
|
|
originalTextFor(value +
|
|
|
SkipTo(
|
|
|
Keyword('by'),
|
|
|
include=False) |
|
|
|
restOfLine
|
|
|
),
|
|
|
delim='by'
|
|
|
)('Values'))
|
|
|
|
|
|
cls._access_value_parser = (Group(Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ originalTextFor(value))('name')
|
|
|
+ originalTextFor(
|
|
|
Optional(Word(alphanums))
|
|
|
)('value'))
|
|
|
|
|
|
cls._access_line_to_delete_parser = (Group(action_symbols('action')
|
|
|
+ access_keyword
|
|
|
+ value
|
|
|
+ restOfLine.suppress())('name'))
|
|
|
|
|
|
# Для парсинга строк с директивами index.
|
|
|
cls._index_line_parser = (Group(Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ Keyword('index')
|
|
|
+ originalTextFor(Word(printables))
|
|
|
)('name')
|
|
|
+ originalTextFor(
|
|
|
OneOrMore(Word(printables))
|
|
|
)('value'))
|
|
|
|
|
|
cls._index_line_to_delete_parser = (Group(action_symbols('action')
|
|
|
+ Keyword('index')
|
|
|
+ originalTextFor(
|
|
|
Word(printables)
|
|
|
))('name'))
|
|
|
|
|
|
# Для парсинга остальных директив.
|
|
|
cls._directive_line_parser = (Group(Optional(action_symbols,
|
|
|
default='')('action')
|
|
|
+ originalTextFor(
|
|
|
Word(printables)
|
|
|
))('name')
|
|
|
+ originalTextFor(
|
|
|
OneOrMore(Word(
|
|
|
printables
|
|
|
)
|
|
|
))('value'))
|
|
|
|
|
|
cls._directive_line_to_delete_parser = (action_symbols('action')
|
|
|
+ originalTextFor(
|
|
|
Word(printables)
|
|
|
))('name')
|
|
|
cls._initialized = True
|
|
|
|
|
|
def _get_list_of_logic_lines(self, text):
|
|
|
'''Метод для разбиения исходного документа на список логических строк,
|
|
|
то есть с учетом того, что строка ldap файла начинающаяся с отступа
|
|
|
является продолжением предыдущей.'''
|
|
|
list_of_lines = []
|
|
|
lines_to_join = []
|
|
|
for line in text.splitlines():
|
|
|
if line.strip() == '':
|
|
|
continue
|
|
|
|
|
|
if not line.startswith(' ') and not line.startswith('\t'):
|
|
|
joined_line = "".join(lines_to_join)
|
|
|
if joined_line != '':
|
|
|
list_of_lines.append(joined_line)
|
|
|
lines_to_join = []
|
|
|
|
|
|
line.strip()
|
|
|
else:
|
|
|
line = ' ' + line.strip()
|
|
|
|
|
|
lines_to_join.append(line)
|
|
|
|
|
|
joined_line = "".join(lines_to_join)
|
|
|
list_of_lines.append(joined_line)
|
|
|
|
|
|
return list_of_lines
|
|
|
|
|
|
def _parse_type_line(self, line):
|
|
|
'''Метод для парсинга строк с объявлением областей backend или database
|
|
|
'''
|
|
|
try:
|
|
|
self._item_to_add = OrderedDict()
|
|
|
parsing_result = self._type_line.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
type_name = tuple(parsing_result.asList())
|
|
|
|
|
|
if self._current_type in self._document_dictionary.keys():
|
|
|
self._document_dictionary[self._current_type].update(
|
|
|
self._current_type_section
|
|
|
)
|
|
|
else:
|
|
|
self._item_to_add[self._current_type] =\
|
|
|
self._current_type_section
|
|
|
self._ready_to_update = True
|
|
|
|
|
|
# Если глобальная область пуста -- передаем ее комментарии
|
|
|
# следующей за ней области.
|
|
|
if self._current_type == ('', 'global') and\
|
|
|
list(self._current_type_section.keys()) == ['#']:
|
|
|
self._last_comments_list = self._current_type_section['#']
|
|
|
self._item_to_add[self._current_type] = OrderedDict()
|
|
|
|
|
|
self._current_type_section = OrderedDict()
|
|
|
self._current_type = type_name
|
|
|
|
|
|
if self._last_comments_list != []:
|
|
|
self._current_type_section['#'] = self._last_comments_list
|
|
|
self._last_comments_list = []
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_notunique_line(self, line):
|
|
|
'''Метод для парсинга строк c директивами неуникальными для секции.
|
|
|
Их приходится парсить полностью как ключ словаря.'''
|
|
|
try:
|
|
|
self._item_to_add = OrderedDict()
|
|
|
parsing_result = self._not_unique_parser.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
parsing_result.value = parsing_result.value.strip()
|
|
|
|
|
|
not_unique_name = tuple(parsing_result.asList())
|
|
|
parameter_value = ['']
|
|
|
|
|
|
parameter_value = self._last_comments_list + parameter_value
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[not_unique_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_access_line(self, line):
|
|
|
'''Метод для парсинга строк содержащих конструкцию
|
|
|
access to <what> by <who>|<access level>|<control>.'''
|
|
|
try:
|
|
|
parsing_result = self._access_line_parser.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
values = [value.strip() for value in
|
|
|
parsing_result.Values.asList()]
|
|
|
values.reverse()
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name)
|
|
|
|
|
|
value_dictionary = OrderedDict()
|
|
|
if self._last_comments_list != []:
|
|
|
value_dictionary['#'] = self._last_comments_list
|
|
|
self._last_comments_list = []
|
|
|
|
|
|
for value in values:
|
|
|
try:
|
|
|
value_parsing = self._access_value_parser.\
|
|
|
parseString(value)
|
|
|
|
|
|
param_name = tuple(value_parsing.name)
|
|
|
param_value = value_parsing.value
|
|
|
value_dictionary[param_name] = [param_value]
|
|
|
except ParseException:
|
|
|
continue
|
|
|
|
|
|
parameter_value = value_dictionary
|
|
|
|
|
|
if parameter_name in self._current_type_section.keys():
|
|
|
self._current_type_section[parameter_name].update(
|
|
|
value_dictionary
|
|
|
)
|
|
|
else:
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_access_line_to_delete(self, line):
|
|
|
'''Метод для парсинга строк, предписывающих удаление конструкций
|
|
|
access to, если указано только ее название и значение What.'''
|
|
|
try:
|
|
|
parsing_result = self._access_line_to_delete_parser.parseString(
|
|
|
line
|
|
|
)
|
|
|
self._match = True
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
|
|
|
if parsing_result.name.action == '-':
|
|
|
return
|
|
|
|
|
|
parameter_value = OrderedDict({'#': self._last_comments_list})
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_syncrepl_line(self, line):
|
|
|
'''Метод для парсинга строк содержащих конструкцию syncrepl
|
|
|
rep=<ReplicaID>.'''
|
|
|
try:
|
|
|
parsing_result = self._syncrepl_line_parser.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
values = [value.strip() for value in
|
|
|
parsing_result.Values.asList()]
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
|
|
|
value_dictionary = OrderedDict()
|
|
|
if self._last_comments_list != []:
|
|
|
value_dictionary['#'] = self._last_comments_list
|
|
|
self._last_comments_list = []
|
|
|
|
|
|
for value in values:
|
|
|
try:
|
|
|
value_parsing = self._syncrepl_value_parser.parseString(
|
|
|
value
|
|
|
)
|
|
|
param_name = tuple(value_parsing.name.asList())
|
|
|
param_value = value_parsing.value
|
|
|
value_dictionary[param_name] = [param_value]
|
|
|
except ParseException:
|
|
|
continue
|
|
|
|
|
|
parameter_value = value_dictionary
|
|
|
|
|
|
if parameter_name in self._current_type_section.keys():
|
|
|
self._current_type_section[parameter_name].update(
|
|
|
value_dictionary
|
|
|
)
|
|
|
else:
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_syncrepl_line_to_delete(self, line):
|
|
|
'''Метод для парсинга строк, предписывающих удаление конструкций
|
|
|
syncrepl rid=<ReplicaID>, если указано только ее название и значение
|
|
|
ReplicaID.'''
|
|
|
try:
|
|
|
parsing_result = self._syncrepl_line_to_delete_parser.parseString(
|
|
|
line
|
|
|
)
|
|
|
self._match = True
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
|
|
|
if parsing_result.name.action == '-':
|
|
|
return
|
|
|
|
|
|
parameter_value = OrderedDict({'#': self._last_comments_list})
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_index_line(self, line):
|
|
|
'''Метод для парсинга строк с директивами index.'''
|
|
|
try:
|
|
|
parsing_result = self._index_line_parser.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
|
|
|
parameter_value = parsing_result.value
|
|
|
|
|
|
parameter_value = self._last_comments_list + [parameter_value]
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_index_line_to_delete(self, line):
|
|
|
'''Метод для парсинга строк, предписывающих удаление директив index,
|
|
|
если указано только из имя, но отсутвует значение.'''
|
|
|
try:
|
|
|
parsing_result = self._index_line_to_delete_parser.parseString(
|
|
|
line
|
|
|
)
|
|
|
self._match = True
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
|
|
|
if parsing_result.name.action == '-':
|
|
|
return
|
|
|
|
|
|
parameter_value = self._last_comments_list
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_plain_directive_line(self, line):
|
|
|
'''Метод для парсинга строк с простыми уникальными для секции
|
|
|
директивами.'''
|
|
|
try:
|
|
|
parsing_result = self._directive_line_parser.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
parameter_value = parsing_result.value
|
|
|
|
|
|
parameter_value = self._last_comments_list + [parameter_value]
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_plain_directive_line_to_delete(self, line):
|
|
|
'''Метод для парсинга строк, предписывающих удаление простых уникальных
|
|
|
директив, если указано только их имя, но отсутствует значение.'''
|
|
|
try:
|
|
|
parsing_result = self._directive_line_to_delete_parser.parseString(
|
|
|
line
|
|
|
)
|
|
|
self._match = True
|
|
|
|
|
|
parameter_name = tuple(parsing_result.name.asList())
|
|
|
|
|
|
if parsing_result.action == '-':
|
|
|
return
|
|
|
|
|
|
parameter_value = self._last_comments_list
|
|
|
self._last_comments_list = []
|
|
|
self._current_type_section[parameter_name] = parameter_value
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _parse_comment_line(self, line):
|
|
|
'''Метод для парсинга строк с комментариями и добавления их в список
|
|
|
комментариев _last_comments_list, предназначенный для сбора
|
|
|
комментариев и последующего их присваивания параметрам и секциям.'''
|
|
|
try:
|
|
|
parsing_result = self._comment_line.parseString(line)
|
|
|
self._match = True
|
|
|
|
|
|
if not self._ignore_comments:
|
|
|
# До того, как первый элемент встречен -- все комментарии
|
|
|
# должны быть присвоены глобальной области.
|
|
|
if self._current_type == ('', 'global') and\
|
|
|
list(self._current_type_section.keys()) == ['#']:
|
|
|
self._current_type_section['#'].append(
|
|
|
parsing_result.comment
|
|
|
)
|
|
|
else:
|
|
|
self._last_comments_list.append(parsing_result.comment)
|
|
|
|
|
|
except ParseException:
|
|
|
return
|
|
|
|
|
|
def _finish_method(self):
|
|
|
'''Метод для завершения парсинга. В данном случае добавляет в итоговый
|
|
|
словарь последнюю разобранную область.'''
|
|
|
self._item_to_add = OrderedDict()
|
|
|
if self._current_type in self._document_dictionary.keys():
|
|
|
self._document_dictionary[self._current_type].update(
|
|
|
self._current_type_section
|
|
|
)
|
|
|
else:
|
|
|
self._item_to_add[self._current_type] = self._current_type_section
|
|
|
self._document_dictionary.update(self._item_to_add)
|
|
|
|
|
|
self._item_to_add = OrderedDict()
|
|
|
self._current_type_section = OrderedDict()
|
