Annotation of embedaddon/strongswan/conf/format-options.py, revision 1.1.1.1
1.1 misho 1: #!/usr/bin/env python
2: #
3: # Copyright (C) 2014-2019 Tobias Brunner
4: # HSR Hochschule fuer Technik Rapperswil
5: #
6: # This program is free software; you can redistribute it and/or modify it
7: # under the terms of the GNU General Public License as published by the
8: # Free Software Foundation; either version 2 of the License, or (at your
9: # option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: #
11: # This program is distributed in the hope that it will be useful, but
12: # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: # for more details.
15:
16: """
17: Parses strongswan.conf option descriptions and produces configuration file
18: and man page snippets.
19:
20: The format for description files is as follows:
21:
22: full.option.name [[:]= default]
23: Short description intended as comment in config snippet
24:
25: Long description for use in the man page, with
26: simple formatting: _italic_, **bold**
27:
28: Second paragraph of the long description
29:
30: The descriptions must be indented by tabs or spaces but are both optional.
31: If only a short description is given it is used for both intended usages.
32: Line breaks within a paragraph of the long description or the short description
33: are not preserved. But multiple paragraphs will be separated in the man page.
34: Any formatting in the short description is removed when producing config
35: snippets.
36:
37: Options for which a value is assigned with := are not commented out in the
38: produced configuration file snippet. This allows to override a default value,
39: that e.g. has to be preserved for legacy reasons, in the generated default
40: config.
41:
42: To describe sections the following format can be used:
43:
44: full.section.name {[#]}
45: Short description of this section
46:
47: Long description as above
48:
49: If a # is added between the curly braces the section header will be commented
50: out in the configuration file snippet, which is useful for example sections.
51:
52: To add include statements to generated config files (ignored when generating
53: man pages) the following format can be used:
54:
55: full.section.name.include files/to/include
56: Description of this include statement
57:
58: Dots in section/option names may be escaped with a backslash. For instance,
59: with the following section description
60:
61: charon.filelog./var/log/daemon\.log {}
62: Section to define logging into /var/log/daemon.log
63:
64: /var/log/daemon.log will be the name of the last section.
65: """
66:
67: import sys
68: import re
69: from textwrap import TextWrapper
70: from argparse import ArgumentParser
71: from functools import cmp_to_key, total_ordering
72:
73: @total_ordering
74: class ConfigOption:
75: """Representing a configuration option or described section in strongswan.conf"""
76: def __init__(self, path, default = None, section = False, commented = False, include = False):
77: self.path = path
78: self.name = path[-1]
79: self.fullname = '.'.join(path)
80: self.default = default
81: self.section = section
82: self.commented = commented
83: self.include = include
84: self.desc = []
85: self.options = []
86:
87: def __eq__(self, other):
88: return self.name == other.name
89:
90: def __lt__(self, other):
91: return self.name < other.name
92:
93: def add_paragraph(self):
94: """Adds a new paragraph to the description"""
95: if len(self.desc) and len(self.desc[-1]):
96: self.desc.append("")
97:
98: def add(self, line):
99: """Adds a line to the last paragraph"""
100: if not len(self.desc):
101: self.desc.append(line)
102: elif not len(self.desc[-1]):
103: self.desc[-1] = line
104: else:
105: self.desc[-1] += ' ' + line
106:
107: def adopt(self, other):
108: """Adopts settings from other, which should be more recently parsed"""
109: self.default = other.default
110: self.commented = other.commented
111: self.desc = other.desc
112:
113: @staticmethod
114: def cmp(a, b):
115: # order options before sections and includes last
116: if a.include or b.include:
117: return a.include - b.include
118: return a.section - b.section
119:
120: class Parser:
121: """Parses one or more files of configuration options"""
122: def __init__(self, sort = True):
123: self.options = []
124: self.sort = sort
125:
126: def parse(self, file):
127: """Parses the given file and adds all options to the internal store"""
128: self.__current = None
129: for line in file:
130: self.__parse_line(line)
131: if self.__current:
132: self.__add_option(self.__current)
133:
134: def __parse_line(self, line):
135: """Parses a single line"""
136: if re.match(r'^\s*#', line):
137: return
138: # option definition
139: m = re.match(r'^(?P<name>\S+)\s*((?P<assign>:)?=\s*(?P<default>.+)?)?\s*$', line)
140: if m:
141: if self.__current:
142: self.__add_option(self.__current)
143: path = self.__split_name(m.group('name'))
144: self.__current = ConfigOption(path, m.group('default'),
145: commented = not m.group('assign'))
146: return
147: # section definition
148: m = re.match(r'^(?P<name>\S+)\s*\{\s*(?P<comment>#)?\s*\}\s*$', line)
149: if m:
150: if self.__current:
151: self.__add_option(self.__current)
152: path = self.__split_name(m.group('name'))
153: self.__current = ConfigOption(path, section = True,
154: commented = m.group('comment'))
155: return
156: # include definition
157: m = re.match(r'^(?P<name>\S+\.include|include)\s+(?P<pattern>\S+)\s*$', line)
158: if m:
159: if self.__current:
160: self.__add_option(self.__current)
161: path = self.__split_name(m.group('name'))
162: self.__current = ConfigOption(path, m.group('pattern'), include = True)
163: return
164: # paragraph separator
165: m = re.match(r'^\s*$', line)
166: if m and self.__current:
167: self.__current.add_paragraph()
168: # description line
169: m = re.match(r'^\s+(?P<text>.+?)\s*$', line)
170: if m and self.__current:
171: self.__current.add(m.group('text'))
172:
173: def __split_name(self, name):
174: """Split the given full name in a list of section/option names"""
175: return [x.replace('\.', '.') for x in re.split(r'(?<!\\)\.', name)]
176:
177: def __add_option(self, option):
178: """Adds the given option to the abstract storage"""
179: option.desc = [desc for desc in option.desc if len(desc)]
180: parent = self.__get_option(option.path[:-1], True)
181: if not parent:
182: parent = self
183: found = next((x for x in parent.options if x.name == option.name
184: and x.section == option.section), None)
185: if found:
186: found.adopt(option)
187: else:
188: parent.options.append(option)
189: if self.sort:
190: parent.options.sort()
191:
192: def __get_option(self, path, create = False):
193: """Searches/Creates the option (section) based on a list of section names"""
194: option = None
195: options = self.options
196: for i, name in enumerate(path, 1):
197: option = next((x for x in options if x.name == name and x.section), None)
198: if not option:
199: if not create:
200: break
201: option = ConfigOption(path[:i], section = True)
202: options.append(option)
203: if self.sort:
204: options.sort()
205: options = option.options
206: return option
207:
208: def get_option(self, name):
209: """Retrieves the option with the given name"""
210: return self.__get_option(self.__split_name(name))
211:
212: class TagReplacer:
213: """Replaces formatting tags in text"""
214: def __init__(self):
215: self.__matcher_b = self.__create_matcher('**')
216: self.__matcher_i = self.__create_matcher('_')
217: self.__replacer = None
218:
219: def __create_matcher(self, tag):
220: tag = re.escape(tag)
221: return re.compile(r'''
222: (^|\s|(?P<brack>[(\[])) # prefix with optional opening bracket
223: (?P<tag>''' + tag + r''') # start tag
224: (?P<text>\S|\S.*?\S) # text
225: ''' + tag + r''' # end tag
226: (?P<punct>([.,!:)\]]|\(\d+\))*) # punctuation
227: (?=$|\s) # suffix (don't consume it so that subsequent tags can match)
228: ''', flags = re.DOTALL | re.VERBOSE)
229:
230: def _create_replacer(self):
231: def replacer(m):
232: punct = m.group('punct')
233: if not punct:
234: punct = ''
235: return '{0}{1}{2}'.format(m.group(1), m.group('text'), punct)
236: return replacer
237:
238: def replace(self, text):
239: if not self.__replacer:
240: self.__replacer = self._create_replacer()
241: text = re.sub(self.__matcher_b, self.__replacer, text)
242: return re.sub(self.__matcher_i, self.__replacer, text)
243:
244: class GroffTagReplacer(TagReplacer):
245: def _create_replacer(self):
246: def replacer(m):
247: nl = '\n' if m.group(1) else ''
248: format = 'I' if m.group('tag') == '_' else 'B'
249: brack = m.group('brack')
250: if not brack:
251: brack = ''
252: punct = m.group('punct')
253: if not punct:
254: punct = ''
255: text = re.sub(r'[\r\n\t]', ' ', m.group('text'))
256: return '{0}.R{1} "{2}" "{3}" "{4}"\n'.format(nl, format, brack, text, punct)
257: return replacer
258:
259: class ConfFormatter:
260: """Formats options to a strongswan.conf snippet"""
261: def __init__(self):
262: self.__indent = ' '
263: self.__wrapper = TextWrapper(width = 80, replace_whitespace = True,
264: break_long_words = False, break_on_hyphens = False)
265: self.__tags = TagReplacer()
266:
267: def __print_description(self, opt, indent):
268: if len(opt.desc):
269: self.__wrapper.initial_indent = '{0}# '.format(self.__indent * indent)
270: self.__wrapper.subsequent_indent = self.__wrapper.initial_indent
271: print(self.__wrapper.fill(self.__tags.replace(opt.desc[0])))
272:
273: def __print_option(self, opt, indent, commented):
274: """Print a single option with description and default value"""
275: comment = "# " if commented or opt.commented else ""
276: self.__print_description(opt, indent)
277: if opt.include:
278: print('{0}{1} {2}'.format(self.__indent * indent, opt.name, opt.default))
279: elif opt.default:
280: print('{0}{1}{2} = {3}'.format(self.__indent * indent, comment, opt.name, opt.default))
281: else:
282: print('{0}{1}{2} ='.format(self.__indent * indent, comment, opt.name))
283: print('')
284:
285: def __print_section(self, section, indent, commented):
286: """Print a section with all options"""
287: commented = commented or section.commented
288: comment = "# " if commented else ""
289: self.__print_description(section, indent)
290: print('{0}{1}{2} {{'.format(self.__indent * indent, comment, section.name))
291: print('')
292: for o in sorted(section.options, key=cmp_to_key(ConfigOption.cmp)):
293: if o.section:
294: self.__print_section(o, indent + 1, commented)
295: else:
296: self.__print_option(o, indent + 1, commented)
297: print('{0}{1}}}'.format(self.__indent * indent, comment))
298: print('')
299:
300: def format(self, options):
301: """Print a list of options"""
302: if not options:
303: return
304: for option in sorted(options, key=cmp_to_key(ConfigOption.cmp)):
305: if option.section:
306: self.__print_section(option, 0, False)
307: else:
308: self.__print_option(option, 0, False)
309:
310: class ManFormatter:
311: """Formats a list of options into a groff snippet"""
312: def __init__(self):
313: self.__wrapper = TextWrapper(width = 80, replace_whitespace = False,
314: break_long_words = False, break_on_hyphens = False)
315: self.__tags = GroffTagReplacer()
316:
317: def __groffize(self, text):
318: """Encode text as groff text"""
319: text = self.__tags.replace(text)
320: text = re.sub(r'(?<!\\)-', r'\\-', text)
321: # remove any leading whitespace
322: return re.sub(r'^\s+', '', text, flags = re.MULTILINE)
323:
324: def __format_option(self, option):
325: """Print a single option"""
326: if option.section and not len(option.desc):
327: return
328: if option.include:
329: return
330: if option.section:
331: print('.TP\n.B {0}\n.br'.format(option.fullname))
332: else:
333: print('.TP')
334: default = option.default if option.default else ''
335: print('.BR {0} " [{1}]"'.format(option.fullname, default))
336: for para in option.desc if len(option.desc) < 2 else option.desc[1:]:
337: print(self.__groffize(self.__wrapper.fill(para)))
338: print('')
339:
340: def format(self, options):
341: """Print a list of options"""
342: if not options:
343: return
344: for option in options:
345: if option.section:
346: self.__format_option(option)
347: self.format(option.options)
348: else:
349: self.__format_option(option)
350:
351: args = ArgumentParser()
352: args.add_argument('file', nargs='*',
353: help="files to process, omit to read input from stdin")
354: args.add_argument("-f", "--format", dest="format", choices=["conf", "man"],
355: help="output format (default: %(default)s)", default="conf")
356: args.add_argument("-r", "--root", dest="root", metavar="NAME",
357: help="root section of which options are printed; everything"
358: "is printed if not found")
359: args.add_argument("-n", "--nosort", action="store_false", dest="sort",
360: default=True, help="do not sort sections alphabetically")
361:
362: opts = args.parse_args()
363:
364: parser = Parser(opts.sort)
365: if len(opts.file):
366: for filename in opts.file:
367: try:
368: with open(filename, 'r') as file:
369: parser.parse(file)
370: except IOError as e:
371: sys.stderr.write("Unable to open '{0}': {1}\n".format(filename, e.strerror))
372: else:
373: parser.parse(sys.stdin)
374:
375: options = parser.options
376: if (opts.root):
377: root = parser.get_option(opts.root)
378: if root:
379: options = root.options
380:
381: if opts.format == "conf":
382: formatter = ConfFormatter()
383: elif opts.format == "man":
384: formatter = ManFormatter()
385:
386: formatter.format(options)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to format-options.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / conf