def format(self, match, colored=False):
formatstr = u"{0} {1}:{2}"
if colored:
color.ANSIBLE_COLOR = True
return formatstr.format(
color.stringc(u"[{0}]".format(match.rule.id), 'bright red'),
color.stringc(normpath(match.filename), 'blue'),
color.stringc(str(match.linenumber), 'cyan'))
else:
return formatstr.format(match.rule.id, normpath(match.filename),
match.linenumber)
def format(self, match, colored=False):
formatstr = u"{0}:{1}: [{2}] {3}"
if colored:
color.ANSIBLE_COLOR = True
return formatstr.format(
color.stringc(normpath(match.filename), 'blue'),
color.stringc(str(match.linenumber), 'cyan'),
color.stringc(u"E{0}".format(match.rule.id), 'bright red'),
color.stringc(u"{0}".format(match.message), 'red'))
else:
return formatstr.format(normpath(match.filename), match.linenumber,
"E" + match.rule.id, match.message)
def format(self, matches):
results = list()
for match in matches:
results.append({
'filename': normpath(match.filename),
'linenumber': str(match.linenumber),
'rule_id': match.rule.id,
'rule_title': str(match.message),
'rule_description': match.rule.description,
'rule_severity': match.rule.severity
})
json_data = json.dumps(results)
print(json_data)
def format(self, match, colored=False):
formatstr = u"{0} {1}\n{2}:{3}\n{4}\n"
if colored:
color.ANSIBLE_COLOR = True
return formatstr.format(
color.stringc(u"[{0}]".format(match.rule.id), 'bright red'),
color.stringc(match.message, 'red'),
color.stringc(normpath(match.filename), 'blue'),
color.stringc(str(match.linenumber), 'cyan'),
color.stringc(u"{0}".format(match.line), 'purple'))
else:
return formatstr.format(match.rule.id, match.message,
match.filename, match.linenumber,
match.line)
def format(self, match, colored=False):
formatstr = u"{0}:{1}: [{2}] [{3}] {4}"
filename = normpath(match.filename)
linenumber = str(match.linenumber)
rule_id = u"E{0}".format(match.rule.id)
severity = match.rule.severity
message = str(match.message)
if colored:
color.ANSIBLE_COLOR = True
filename = color.stringc(filename, 'blue')
linenumber = color.stringc(linenumber, 'cyan')
rule_id = color.stringc(rule_id, 'bright red')
severity = color.stringc(severity, 'bright red')
message = color.stringc(message, 'red')
return formatstr.format(
filename,
linenumber,
rule_id,
severity,
message,
)
def main():
formatter = formatters.Formatter()
parser = optparse.OptionParser(
"%prog [options] [playbook.yml [playbook2 ...]]|roledirectory",
version="%prog " + __version__)
parser.add_option('-L',
dest='listrules',
default=False,
action='store_true',
help="list all the rules")
parser.add_option('-q',
dest='quiet',
default=False,
action='store_true',
help="quieter, although not silent output")
parser.add_option('-p',
dest='parseable',
default=False,
action='store_true',
help="parseable output in the format of pep8")
parser.add_option('--parseable-severity',
dest='parseable_severity',
default=False,
action='store_true',
help="parseable output including severity of rule")
parser.add_option('-r',
action='append',
dest='rulesdir',
default=[],
type='str',
help="specify one or more rules directories using "
"one or more -r arguments. Any -r flags override "
"the default rules in %s, unless -R is also used." %
default_rulesdir)
parser.add_option('-R',
action='store_true',
default=False,
dest='use_default_rules',
help="Use default rules in %s in addition to any extra "
"rules directories specified with -r. There is "
"no need to specify this if no -r flags are used" %
default_rulesdir)
parser.add_option('-t',
dest='tags',
action='append',
default=[],
help="only check rules whose id/tags match these values")
parser.add_option('-T',
dest='listtags',
action='store_true',
help="list all the tags")
parser.add_option('-v',
dest='verbosity',
action='count',
help="Increase verbosity level",
default=0)
parser.add_option('-x',
dest='skip_list',
default=[],
action='append',
help="only check rules whose id/tags do not " +
"match these values")
parser.add_option('--nocolor',
dest='colored',
default=hasattr(sys.stdout, 'isatty')
and sys.stdout.isatty(),
action='store_false',
help="disable colored output")
parser.add_option(
'--force-color',
dest='colored',
action='store_true',
help="Try force colored output (relying on ansible's code)")
parser.add_option('--exclude',
dest='exclude_paths',
action='append',
help='path to directories or files to skip. This option'
' is repeatable.',
default=[])
parser.add_option(
'-c',
dest='config_file',
help='Specify configuration file to use. Defaults to ".ansible-lint"')
options, args = parser.parse_args(sys.argv[1:])
config = load_config(options.config_file)
if config:
if 'quiet' in config:
options.quiet = options.quiet or config['quiet']
if 'parseable' in config:
options.parseable = options.parseable or config['parseable']
if 'parseable_severity' in config:
options.parseable_severity = options.parseable_severity or \
config['parseable_severity']
if 'use_default_rules' in config:
options.use_default_rules = options.use_default_rules or config[
'use_default_rules']
if 'verbosity' in config:
options.verbosity = options.verbosity + config['verbosity']
options.exclude_paths.extend(config.get('exclude_paths', []))
if 'rulesdir' in config:
options.rulesdir = options.rulesdir + config['rulesdir']
if 'skip_list' in config:
options.skip_list = options.skip_list + config['skip_list']
if 'tags' in config:
options.tags = options.tags + config['tags']
if options.quiet:
formatter = formatters.QuietFormatter()
if options.parseable:
formatter = formatters.ParseableFormatter()
if options.parseable_severity:
formatter = formatters.ParseableSeverityFormatter()
# no args triggers auto-detection mode
if len(args) == 0 and not (options.listrules or options.listtags):
args = get_playbooks_and_roles(options=options)
if options.use_default_rules:
rulesdirs = options.rulesdir + [default_rulesdir]
else:
rulesdirs = options.rulesdir or [default_rulesdir]
rules = RulesCollection()
for rulesdir in rulesdirs:
rules.extend(RulesCollection.create_from_directory(rulesdir))
if options.listrules:
print(rules)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, six.string_types):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
playbooks = sorted(set(args))
matches = list()
checked_files = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags, options.skip_list,
options.exclude_paths, options.verbosity,
checked_files)
matches.extend(runner.run())
matches.sort(key=lambda x: (normpath(x.filename), x.linenumber, x.rule.id))
for match in matches:
print(formatter.format(match, options.colored))
if len(matches):
return 2
else:
return 0
def main():
cwd = pathlib.Path.cwd()
options = cli.get_config(sys.argv[1:])
initialize_logger(options.verbosity)
formatter_factory = formatters.Formatter
if options.quiet:
formatter_factory = formatters.QuietFormatter
if options.parseable:
formatter_factory = formatters.ParseableFormatter
if options.parseable_severity:
formatter_factory = formatters.ParseableSeverityFormatter
formatter = formatter_factory(cwd, options.display_relative_path)
# no args triggers auto-detection mode
if not options.playbook and not (options.listrules or options.listtags):
cli.print_help(file=sys.stderr)
return 1
if options.use_default_rules:
rulesdirs = options.rulesdir + [default_rulesdir]
else:
rulesdirs = options.rulesdir or [default_rulesdir]
rules = RulesCollection(rulesdirs)
if options.listrules:
print(rules)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
playbooks = sorted(set(options.playbook))
matches = list()
checked_files = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags,
options.skip_list, options.exclude_paths,
options.verbosity, checked_files)
matches.extend(runner.run())
matches.sort(key=lambda x: (normpath(x.filename), x.linenumber, x.rule.id))
for match in matches:
print(formatter.format(match, options.colored))
if len(matches):
return 2
else:
return 0
def test_normpath_with_path_object(path):
assert utils.normpath(path) == "a"
def lint(book_id, options, config=None):
"""
base on ansiblelint
refer to ansiblelint.__main__.py
:param book_id:
:param options:
:param config:
:return: None
"""
formatter = formatters.Formatter()
options = get_default_options(options)
where = {
'book_id': str(book_id),
'role': 'entry',
}
entries = Playbook.find(where)
if not entries:
return False
book = Book.find_by_id(book_id)
if not book:
return False
if config:
if 'quiet' in config:
options.quiet = options.quiet or config['quiet']
if 'parseable' in config:
options.parseable = options.parseable or config['parseable']
if 'parseable_severity' in config:
options.parseable_severity = options.parseable_severity or \
config['parseable_severity']
if 'use_default_rules' in config:
options.use_default_rules = options.use_default_rules or config['use_default_rules']
if 'verbosity' in config:
options.verbosity = options.verbosity + config['verbosity']
options.exclude_paths.extend(
config.get('exclude_paths', []))
if 'rulesdir' in config:
options.rulesdir = options.rulesdir + config['rulesdir']
if 'skip_list' in config:
options.skip_list = options.skip_list + config['skip_list']
if 'tags' in config:
options.tags = options.tags + config['tags']
if options.quiet:
formatter = formatters.QuietFormatter()
if options.parseable:
formatter = formatters.ParseableFormatter()
if options.parseable_severity:
formatter = formatters.ParseableSeverityFormatter()
# no args triggers auto-detection mode
# if len(args) == 0 and not (options.listrules or options.listtags):
# args = get_playbooks_and_roles(options=options)
if options.use_default_rules:
rulesdirs = options.rulesdir + [default_rulesdir]
else:
rulesdirs = options.rulesdir or [default_rulesdir]
rules = RulesCollection()
for rulesdir in rulesdirs:
rules.extend(RulesCollection.create_from_directory(rulesdir))
if options.listrules:
return 0
if options.listtags:
return 0
if isinstance(options.tags, six.string_types):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
with build_book_from_db(book.get('name'), options.get('roles')) as book_path:
playbooks = []
for record in entries:
entry = os.path.join(book_path, record['path'][1:])
playbooks.append(entry)
playbooks = sorted(set(playbooks))
matches = list()
checked_files = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags,
options.skip_list, options.exclude_paths,
options.verbosity, checked_files)
matches.extend(runner.run())
matches.sort(key=lambda x: (normpath(x.filename), x.linenumber, x.rule.id))
results = []
for match in matches:
filename = str(match.filename)
filename = filename.replace(book_path, '')
results.append({
'lineNumber': match.linenumber,
'line': str(match.line),
'rule': match.rule.id,
'filename': filename,
'message': match.message,
})
return results
def main():
"""Linter CLI entry point."""
cwd = pathlib.Path.cwd()
options = cli.get_config(sys.argv[1:])
initialize_logger(options.verbosity)
_logger.debug("Options: %s", options)
formatter_factory: Any = formatters.Formatter
if options.quiet:
formatter_factory = formatters.QuietFormatter
if options.parseable:
formatter_factory = formatters.ParseableFormatter
if options.parseable_severity:
formatter_factory = formatters.ParseableSeverityFormatter
formatter = formatter_factory(cwd, options.display_relative_path)
if options.use_default_rules:
rulesdirs = options.rulesdir + [default_rulesdir]
else:
rulesdirs = options.rulesdir or [default_rulesdir]
rules = RulesCollection(rulesdirs)
if options.listrules:
formatted_rules = rules if options.format == 'plain' else rules_as_rst(rules)
print(formatted_rules)
return 0
if options.listtags:
print(rules.listtags())
return 0
if isinstance(options.tags, str):
options.tags = options.tags.split(',')
skip = set()
for s in options.skip_list:
skip.update(str(s).split(','))
options.skip_list = frozenset(skip)
if not options.playbook:
# no args triggers auto-detection mode
playbooks = get_playbooks_and_roles(options=options)
else:
playbooks = sorted(set(options.playbook))
matches = list()
checked_files: Set[Any] = set()
for playbook in playbooks:
runner = Runner(rules, playbook, options.tags,
options.skip_list, options.exclude_paths,
options.verbosity, checked_files)
matches.extend(runner.run())
matches.sort(key=lambda x: (normpath(x.filename), x.linenumber, x.rule.id))
for match in matches:
print(formatter.format(match, options.colored))
if len(matches):
return 2
else:
return 0
def test_normpath_with_string(self):
self.assertEqual(
utils.normpath("a/b/../"),
"a")
def test_normpath_with_path_object(self):
self.assertEqual(
utils.normpath(Path("a/b/../")),
"a")
