def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(
RulesCollection.create_from_directory(rulesdir))
self.filenames = {
"config_rule": {
"filename": 'fixtures/templates/quickstart/config-rules.json',
"failures": 4
},
"iam": {
"filename": 'fixtures/templates/quickstart/iam.json',
"failures": 4
},
"nat_instance": {
"filename": 'fixtures/templates/quickstart/nat-instance.json',
"failures": 2
},
"vpc_management": {
"filename": 'fixtures/templates/quickstart/vpc-management.json',
"failures": 35
},
"vpc": {
"filename": 'fixtures/templates/quickstart/vpc.json',
"failures": 40
},
"poller": {
"filename": 'fixtures/templates/public/lambda-poller.json',
"failures": 0
}
}
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(
RulesCollection.create_from_directory(rulesdir))
def get_rules(rulesdir, ignore_rules):
"""Get rules"""
rules = RulesCollection(ignore_rules)
rules_dirs = [DEFAULT_RULESDIR] + rulesdir
for rules_dir in rules_dirs:
rules.extend(RulesCollection.create_from_directory(rules_dir))
return rules
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(
RulesCollection.create_from_directory(rulesdir))
self.filenames = {
'config_rule': {
"filename": 'fixtures/templates/public/lambda-poller.yaml',
"failures": 0
},
'watchmaker': {
"filename": 'fixtures/templates/public/watchmaker.json',
"failures": 0
},
'nist_high_master': {
'filename': 'fixtures/templates/quickstart/nist_high_master.yaml',
'results_filename': 'fixtures/results/quickstart/nist_high_master.json'
},
'nist_application': {
'filename': 'fixtures/templates/quickstart/nist_application.yaml',
'results_filename': 'fixtures/results/quickstart/nist_application.json'
},
'nist_config_rules': {
'filename': 'fixtures/templates/quickstart/nist_config_rules.yaml',
'results_filename': 'fixtures/results/quickstart/nist_config_rules.json'
},
'nist_iam': {
'filename': 'fixtures/templates/quickstart/nist_iam.yaml',
'results_filename': 'fixtures/results/quickstart/nist_iam.json'
},
'nist_logging': {
'filename': 'fixtures/templates/quickstart/nist_logging.yaml',
'results_filename': 'fixtures/results/quickstart/nist_logging.json'
},
'nist_vpc_management': {
'filename': 'fixtures/templates/quickstart/nist_vpc_management.yaml',
'results_filename': 'fixtures/results/quickstart/nist_vpc_management.json'
},
'nist_vpc_production': {
'filename': 'fixtures/templates/quickstart/nist_vpc_production.yaml',
'results_filename': 'fixtures/results/quickstart/nist_vpc_production.json'
},
'openshift_master': {
'filename': 'fixtures/templates/quickstart/openshift_master.yaml',
'failures': 0
},
'openshift': {
'filename': 'fixtures/templates/quickstart/openshift.yaml',
'results_filename': 'fixtures/results/quickstart/openshift.json'
},
'cis_benchmark': {
'filename': 'fixtures/templates/quickstart/cis_benchmark.yaml',
'results_filename': 'fixtures/results/quickstart/cis_benchmark.json'
}
}
def get_rules(rulesdir, ignore_rules, include_rules):
"""Get rules"""
rules = RulesCollection(ignore_rules, include_rules)
rules_dirs = [DEFAULT_RULESDIR] + rulesdir
try:
for rules_dir in rules_dirs:
rules.extend(
RulesCollection.create_from_directory(rules_dir))
except OSError as e:
raise UnexpectedRuleException('Tried to append rules but got an error: %s' % str(e), 1)
return rules
def get_rules(rulesdir, ignore_rules):
"""Get rules"""
rules = RulesCollection(ignore_rules)
rules_dirs = [DEFAULT_RULESDIR] + rulesdir
try:
for rules_dir in rules_dirs:
rules.extend(RulesCollection.create_from_directory(rules_dir))
except OSError as e:
LOGGER.error('Tried to append rules but got an error: %s', str(e))
exit(1)
return rules
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(RulesCollection.create_from_directory(rulesdir))
self.filenames = {
"config_rule": {
"filename": 'fixtures/templates/public/lambda-poller.yaml',
"failures": 0
}
}
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection(include_rules=['I'])
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(RulesCollection.create_from_directory(rulesdir))
self.filenames = {
'generic': {
"filename": 'test/fixtures/templates/good/generic.yaml',
"failures": 0
},
'minimal': {
"filename": 'test/fixtures/templates/good/minimal.yaml',
"failures": 0
},
'transform': {
"filename": 'test/fixtures/templates/good/transform.yaml',
"failures": 0
},
'transform_bad': {
"filename":
'test/fixtures/templates/bad/transform_serverless_template.yaml',
"failures": 3
},
'conditions': {
"filename": 'test/fixtures/templates/good/conditions.yaml',
"failures": 0
},
'resources_codepipeline': {
'filename':
'test/fixtures/templates/good/resources_codepipeline.yaml',
'failures': 0
},
'transform_serverless_api': {
'filename':
'test/fixtures/templates/good/transform_serverless_api.yaml',
'failures': 0
},
'transform_serverless_function': {
'filename':
'test/fixtures/templates/good/transform_serverless_function.yaml',
'failures': 0
},
'transform_serverless_globals': {
'filename':
'test/fixtures/templates/good/transform_serverless_globals.yaml',
'failures': 0
}
}
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.create_from_directory(rulesdir)
self.filenames = {
"config_rule": {
"filename":
'test/fixtures/templates/public/lambda-poller.yaml',
"failures": 1
},
"generic_bad": {
"filename": 'test/fixtures/templates/bad/generic.yaml',
"failures": 35
}
}
def test_success_filtering_of_rules_default(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_w0000(CloudFormationLintRule):
"""Warning Rule"""
id = 'W0000'
class rule_i0000(CloudFormationLintRule):
"""Info Rule"""
id = 'I0000'
rules_to_add = [rule_e0000, rule_w0000, rule_i0000]
rules = RulesCollection(ignore_rules=None, include_rules=None)
rules.extend(rules_to_add)
self.assertEqual(len(rules), 2)
for rule in rules:
self.assertIn(rule.id, ['W0000', 'E0000'])
def test_success_filtering_of_rules_exclude_longer(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_e0010(CloudFormationLintRule):
"""Error Rule"""
id = 'E0010'
class rule_e0002(CloudFormationLintRule):
"""Error Rule"""
id = 'E0002'
rules_to_add = [rule_e0000, rule_e0010, rule_e0002]
rules = RulesCollection(ignore_rules=['E0002'])
rules.extend(rules_to_add)
self.assertEqual(len(rules), 2)
for rule in rules:
self.assertIn(rule.id, ['E0000', 'E0010'])
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection(
include_rules=['I'],
include_experimental=True,
configure_rules={'E3012': {
'strict': 'false'
}})
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.create_from_directory(rulesdir)
self.filenames = {
'nist_high_master': {
'filename':
'test/fixtures/templates/quickstart/nist_high_master.yaml',
'results_filename':
'test/fixtures/results/quickstart/non_strict/nist_high_master.json'
},
'nist_application': {
'filename':
'test/fixtures/templates/quickstart/nist_application.yaml',
'results_filename':
'test/fixtures/results/quickstart/non_strict/nist_application.json'
},
'openshift': {
'filename':
'test/fixtures/templates/quickstart/openshift.yaml',
'results_filename':
'test/fixtures/results/quickstart/non_strict/openshift.json'
},
'cis_benchmark': {
'filename':
'test/fixtures/templates/quickstart/cis_benchmark.yaml',
'results_filename':
'test/fixtures/results/quickstart/non_strict/cis_benchmark.json'
}
}
def setUp(self):
"""Setup"""
self.collection = RulesCollection()
self.collection.register(Required())
def setUp(self):
"""Setup"""
self.collection = RulesCollection()
self.collection.register(Configuration())
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection(include_rules=['I'])
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.create_from_directory(rulesdir)
def setUp(self):
"""Setup"""
self.collection = RulesCollection(include_rules=['I'], include_experimental=True)
def main():
"""Main Function"""
parser = ArgumentParser(description='CloudFormation Linter')
parser.add_argument(
'--template', help='CloudFormation Template')
parser.add_argument(
'--ignore-bad-template', help='Ignore failures with Bad template',
action='store_true'
)
parser.add_argument(
'--log-level', help='Log Level', choices=['info', 'debug']
)
parser.add_argument(
'--format', help='Output Format', choices=['quiet', 'parseable', 'json']
)
defaults = {}
args = parser.parse_known_args()
template = {}
configure_logging(vars(args[0])['log_level'])
if vars(args[0])['template']:
(defaults, template) = cfnlint.helpers.get_template_default_args(
vars(args[0])['template'],
vars(args[0])['ignore_bad_template'])
parser.add_argument(
'--list-rules', dest='listrules', default=False,
action='store_true', help='list all the rules'
)
parser.add_argument(
'--regions', dest='regions', default=['us-east-1'], nargs='*',
help='list the regions to validate against.'
)
parser.add_argument(
'--append-rules', dest='rulesdir', default=[], nargs='*',
help='specify one or more rules directories using '
'one or more --append-rules arguments. '
)
parser.add_argument(
'--ignore-checks', dest='ignore_checks', default=[], nargs='*',
help='only check rules whose id do not match these values'
)
parser.add_argument(
'--override-spec', dest='override_spec',
help='A CloudFormation Spec override file that allows customization'
)
parser.add_argument(
'--version', help='Version of cfn-lint', action='version',
version='%(prog)s {version}'.format(version=__version__)
)
parser.add_argument(
'--update-specs', help='Update the CloudFormation Specs',
action='store_true'
)
parser.set_defaults(**defaults)
args = parser.parse_args()
if vars(args)['format']:
if vars(args)['format'] == 'quiet':
formatter = formatters.QuietFormatter()
elif vars(args)['format'] == 'parseable':
# pylint: disable=bad-option-value
formatter = formatters.ParseableFormatter()
else:
formatter = formatters.Formatter()
if vars(args)['override_spec']:
cfnlint.helpers.override_specs(vars(args)['override_spec'])
if vars(args)['update_specs']:
cfnlint.helpers.update_resource_specs()
exit(0)
rules = RulesCollection()
rulesdirs = [cfnlint.DEFAULT_RULESDIR] + vars(args)['rulesdir']
for rulesdir in rulesdirs:
rules.extend(
RulesCollection.create_from_directory(rulesdir))
if vars(args)['listrules']:
print(rules)
return 0
transforms = TransformsCollection()
transformdirs = [cfnlint.DEFAULT_TRANSFORMSDIR]
for transformdir in transformdirs:
transforms.extend(
TransformsCollection.create_from_directory(transformdir))
if not vars(args)['template']:
parser.print_help()
exit(1)
matches = cfnlint.helpers.run_checks(
vars(args)['template'], template, rules, transforms, vars(args)['ignore_checks'],
vars(args)['regions'])
exit_code = 0
for match in matches:
if match.rule.id[0] == 'W':
exit_code = exit_code | 4
elif match.rule.id[0] == 'E':
exit_code = exit_code | 2
if vars(args)['format'] == 'json':
print(json.dumps(matches, indent=4, cls=CustomEncoder))
else:
for match in matches:
print(formatter.format(match))
return exit_code
def test_update_iam_policies(self):
"""Success update documentation"""
class TestRuleError(CloudFormationLintRule):
""" Def Rule """
id = 'E1000'
shortdesc = 'Test Error'
description = 'Test Description'
source_url = 'https://github.com/aws-cloudformation/cfn-python-lint/'
tags = ['resources']
class TestRuleExpiremental(CloudFormationLintRule):
""" Def Rule """
id = 'E1001'
shortdesc = 'Test Expiremental'
description = 'Test Description'
source_url = 'https://github.com/aws-cloudformation/cfn-python-lint/'
tags = ['resources']
experimental = True
class TestRuleWarning(CloudFormationLintRule):
""" Def Rule """
id = 'W1001'
shortdesc = 'Test Warning'
description = 'Test Description'
source_url = 'https://github.com/aws-cloudformation/cfn-python-lint/'
tags = ['resources', 'iam']
collection = RulesCollection(include_rules=['I'], include_experimental=True)
collection.register(TestRuleError())
collection.register(TestRuleWarning())
collection.register(TestRuleExpiremental())
if sys.version_info.major == 3:
builtin_module_name = 'builtins'
else:
builtin_module_name = '__builtin__'
mo = mock_open(read_data=self.TEST_TEXT)
mo.return_value.__iter__ = lambda self: self
mo.return_value.__iter__ = lambda self: iter(self.readline, '')
with patch('{}.open'.format(builtin_module_name), mo) as mock_builtin_open:
cfnlint.maintenance.update_documentation(collection)
expected_calls = [
call('\n'),
call('Regular Text\n'),
call('## Rules\n'),
call('The following **{}** rules are applied by this linter:\n'.format(
len(collection))),
call('(_This documentation is generated from the Rules, do not alter this manually_)\n\n'),
call('| Rule ID | Title | Description | Config<br />(Name:Type:Default) | Source | Tags |\n'),
call('| -------- | ----- | ----------- | ---------- | ------ | ---- |\n'),
call(
'| E0000<a name="E0000"></a> | Parsing error found when parsing the template | Checks for Null values and Duplicate values in resources | | [Source]() | `base` |\n'),
call(
'| E0001<a name="E0001"></a> | Error found when transforming the template | Errors found when performing transformation on the template | | [Source]() | `base`,`transform` |\n'),
call(
'| E0002<a name="E0002"></a> | Error processing rule on the template | Errors found when processing a rule on the template | | [Source]() | `base`,`rule` |\n'),
call(
'| E1000<a name="E1000"></a> | Test Error | Test Description | | [Source](https://github.com/aws-cloudformation/cfn-python-lint/) | `resources` |\n'),
call(
'| W1001<a name="W1001"></a> | Test Warning | Test Description | | [Source](https://github.com/aws-cloudformation/cfn-python-lint/) | `resources`,`iam` |\n'),
call('### Experimental rules\n'),
call('| Rule ID | Title | Description | Source | Tags |\n'),
call('| -------- | ----- | ----------- | ------ | ---- |\n'),
call(
'| E1001<a name="E1001"></a> | Test Expiremental | Test Description | | [Source](https://github.com/aws-cloudformation/cfn-python-lint/) | `resources` |\n'),
]
mock_builtin_open.return_value.write.assert_has_calls(expected_calls)
self.assertEqual(len(expected_calls), mock_builtin_open.return_value.write.call_count)
def main():
"""Main Function"""
parser = ArgumentParser(description='CloudFormation Linter')
parser.add_argument('--template', help='CloudFormation Template')
parser.add_argument('--ignore-bad-template',
help='Ignore failures with Bad template',
action='store_true')
parser.add_argument('--log-level',
help='Log Level',
choices=['info', 'debug'])
defaults = {}
args = parser.parse_known_args()
template = {}
# Setup Logging
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
if vars(args[0])['log_level'] == 'info':
LOGGER.setLevel(logging.INFO)
elif vars(args[0])['log_level'] == 'debug':
LOGGER.setLevel(logging.DEBUG)
else:
LOGGER.setLevel(logging.ERROR)
log_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(log_formatter)
LOGGER.addHandler(ch)
# Read template to get configuration items
if vars(args[0])['template']:
try:
filename = vars(args[0])['template']
fp = open(filename)
loader = cfnlint.parser.MarkedLoader(fp.read())
loader.add_multi_constructor('!', cfnlint.parser.multi_constructor)
template = loader.get_single_data()
if template is dict:
defaults = template.get('Metadata',
{}).get('cfn-lint',
{}).get('config', {})
except IOError as e:
if e.errno == 2:
LOGGER.error('Template file not found: %s', filename)
sys.exit(1)
elif e.errno == 21:
LOGGER.error('Template references a directory, not a file: %s',
filename)
sys.exit(1)
elif e.errno == 13:
LOGGER.error(
'Permission denied when accessing template file: %s',
filename)
sys.exit(1)
except DuplicateError as err:
LOGGER.error('Template %s contains duplicates: %s', filename, err)
sys.exit(1)
except NullError as err:
LOGGER.error('Template %s contains nulls: %s', filename, err)
sys.exit(1)
except (ParserError, ScannerError) as err:
try:
template = json.load(open(filename),
cls=cfnlint.cfn_json.CfnJSONDecoder)
except cfnlint.cfn_json.JSONDecodeError as json_err:
if vars(args[0])['ignore_bad_template']:
LOGGER.info('Template %s is malformed: %s', filename,
err.problem)
LOGGER.error('Tried to parse %s as JSON but got error: %s',
filename, str(json_err))
else:
LOGGER.error('Template %s is malformed: %s', filename,
err.problem)
LOGGER.error('Tried to parse %s as JSON but got error: %s',
filename, str(json_err))
sys.exit(1)
except Exception as json_err: # pylint: disable=W0703
if vars(args[0])['ignore_bad_template']:
LOGGER.info('Template %s is malformed: %s', filename,
err.problem)
LOGGER.info('Tried to parse %s as JSON but got error: %s',
filename, str(json_err))
else:
LOGGER.error('Template %s is malformed: %s', filename,
err.problem)
LOGGER.error('Tried to parse %s as JSON but got error: %s',
filename, str(json_err))
sys.exit(1)
parser.add_argument('--format',
help='Output Format',
choices=['quiet', 'parseable', 'json'])
parser.add_argument('--list-rules',
dest='listrules',
default=False,
action='store_true',
help='list all the rules')
parser.add_argument('--regions',
dest='regions',
default=['us-east-1'],
nargs='*',
help='list the regions to validate against.')
parser.add_argument('--append-rules',
dest='rulesdir',
default=[],
nargs='*',
help='specify one or more rules directories using '
'one or more --append-rules arguments. ')
parser.add_argument(
'--ignore-checks',
dest='ignore_checks',
default=[],
nargs='*',
help='only check rules whose id do not match these values')
parser.add_argument(
'--override-spec',
dest='override_spec',
help='A CloudFormation Spec override file that allows customization')
parser.add_argument(
'--version',
help='Version of cfn-lint',
action='version',
version='%(prog)s {version}'.format(version=__version__))
parser.add_argument('--update-specs',
help='Update the CloudFormation Specs',
action='store_true')
parser.set_defaults(**defaults)
args = parser.parse_args()
if vars(args)['format']:
if vars(args)['format'] == 'quiet':
formatter = formatters.QuietFormatter()
elif vars(args)['format'] == 'parseable':
# pylint: disable=bad-option-value
formatter = formatters.ParseableFormatter()
else:
formatter = formatters.Formatter()
if vars(args)['override_spec']:
try:
filename = vars(args)['override_spec']
custom_spec_data = json.load(open(filename))
cfnlint.helpers.override_specs(custom_spec_data)
except IOError as e:
if e.errno == 2:
LOGGER.error('Override spec file not found: %s', filename)
sys.exit(1)
elif e.errno == 21:
LOGGER.error(
'Override spec file references a directory, not a file: %s',
filename)
sys.exit(1)
elif e.errno == 13:
LOGGER.error(
'Permission denied when accessing override spec file: %s',
filename)
sys.exit(1)
except (ValueError) as err:
LOGGER.error('Override spec file %s is malformed: %s', filename,
err)
sys.exit(1)
if vars(args)['update_specs']:
cfnlint.helpers.update_resource_specs()
exit(0)
rules = RulesCollection()
rulesdirs = [cfnlint.DEFAULT_RULESDIR] + vars(args)['rulesdir']
for rulesdir in rulesdirs:
rules.extend(RulesCollection.create_from_directory(rulesdir))
if vars(args)['listrules']:
print(rules)
return 0
transforms = TransformsCollection()
transformdirs = [cfnlint.DEFAULT_TRANSFORMSDIR]
for transformdir in transformdirs:
transforms.extend(
TransformsCollection.create_from_directory(transformdir))
if vars(args)['regions']:
supported_regions = [
'ap-south-1', 'sa-east-1', 'ap-northeast-1', 'ap-northeast-2',
'ap-southeast-1', 'ap-southeast-2', 'ca-central-1', 'eu-central-1',
'eu-west-1', 'eu-west-2', 'us-west-2', 'us-east-1', 'us-east-2',
'us-west-1'
]
for region in vars(args)['regions']:
if region not in supported_regions:
LOGGER.error('Supported regions are %s', supported_regions)
return (32)
exit_code = 0
if vars(args)['template']:
matches = list()
runner = cfnlint.Runner(rules, transforms,
vars(args)['template'], template,
vars(args)['ignore_checks'],
vars(args)['regions'])
matches.extend(runner.transform())
# Only do rule analysis if Transform was successful
if not matches:
try:
matches.extend(runner.run())
except Exception as err: # pylint: disable=W0703
LOGGER.error(
'Tried to process rules on file %s but got an error: %s',
filename, str(err))
exit(1)
matches.sort(key=lambda x: (x.filename, x.linenumber, x.rule.id))
for match in matches:
if match.rule.id[0] == 'W':
exit_code = exit_code | 4
elif match.rule.id[0] == 'E':
exit_code = exit_code | 2
if vars(args)['format'] == 'json':
print(json.dumps(matches, indent=4, cls=CustomEncoder))
else:
for match in matches:
print(formatter.format(match))
else:
parser.print_help()
return exit_code
def setUp(self):
"""Setup"""
self.collection = RulesCollection()
self.transforms = TransformsCollection()
self.transforms.extend(
TransformsCollection.create_from_directory(DEFAULT_TRANSFORMSDIR))
def setUp(self):
"""Setup"""
self.collection = RulesCollection()
self.collection.register(ImageId())
def setUp(self):
"""Setup"""
self.collection = RulesCollection()
def main():
"""Main Function"""
parser = argparse.ArgumentParser(description='CloudFormation Linter')
parser.add_argument(
'--template', help='CloudFormation Template')
parser.add_argument(
'--ignore-bad-template', help='Ignore failures with Bad template',
action='store_true'
)
parser.add_argument(
'--log-level', help='Log Level', choices=['info', 'debug']
)
defaults = {}
args = parser.parse_known_args()
template = {}
# Setup Logging
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
if vars(args[0])['log_level'] == 'info':
LOGGER.setLevel(logging.INFO)
elif vars(args[0])['log_level'] == 'debug':
LOGGER.setLevel(logging.DEBUG)
else:
LOGGER.setLevel(logging.ERROR)
log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(log_formatter)
LOGGER.addHandler(ch)
# Read template to get configuration items
if vars(args[0])['template']:
try:
filename = vars(args[0])['template']
fp = open(filename)
loader = cfnlint.parser.MarkedLoader(fp.read())
loader.add_multi_constructor("!", cfnlint.parser.multi_constructor)
template = loader.get_single_data()
if template is dict:
defaults = template.get('Metadata', {}).get('cfn-lint', {}).get('config', {})
except IOError as e:
if e.errno == 2:
LOGGER.error("Template file not found: %s", filename)
sys.exit(1)
elif e.errno == 21:
LOGGER.error("Template references a directory, not a file: %s", filename)
sys.exit(1)
elif e.errno == 13:
LOGGER.error("Permission denied when accessing template file: %s", filename)
sys.exit(1)
except (ParserError, ScannerError) as err:
if vars(args[0])['ignore_bad_template']:
LOGGER.info('Template %s is maflormed: %s', filename, err)
else:
LOGGER.error('Template %s is maflormed: %s', filename, err)
sys.exit(1)
parser.add_argument(
'--format', help='Output Format', choices=['quiet', 'parseable', 'json']
)
parser.add_argument(
'--list-rules', dest='listrules', default=False,
action='store_true', help="list all the rules"
)
parser.add_argument(
'--regions', dest='regions', default=['us-east-1'], nargs='*',
help="list the regions to validate against."
)
parser.add_argument(
'--append-rules', dest='rulesdir', default=[], nargs='*',
help="specify one or more rules directories using "
"one or more --append-rules arguments. "
)
parser.add_argument(
'--ignore-checks', dest='ignore_checks', default=[], nargs='*',
help="only check rules whose id do not match these values"
)
parser.add_argument(
'--version', help='Version of cfn-lint', action='version',
version='%(prog)s {version}'.format(version=__version__)
)
parser.add_argument(
'--update-specs', help='Update the CloudFormation Specs',
action='store_true'
)
parser.set_defaults(**defaults)
args = parser.parse_args()
if vars(args)['format']:
if vars(args)['format'] == 'quiet':
formatter = formatters.QuietFormatter()
elif vars(args)['format'] == 'parseable':
# pylint: disable=bad-option-value
formatter = formatters.ParseableFormatter()
else:
formatter = formatters.Formatter()
if vars(args)['update_specs']:
cfnlint.helpers.update_resource_specs()
exit(0)
rules = RulesCollection()
rulesdirs = [cfnlint.DEFAULT_RULESDIR] + vars(args)['rulesdir']
for rulesdir in rulesdirs:
rules.extend(
RulesCollection.create_from_directory(rulesdir))
if vars(args)['listrules']:
print(rules)
return 0
if vars(args)['regions']:
supported_regions = [
'ap-south-1',
'sa-east-1',
'ap-northeast-1',
'ap-northeast-2',
'ap-southeast-1',
'ap-southeast-2',
'ca-central-1',
'eu-central-1',
'eu-west-1',
'eu-west-2',
'us-west-2',
'us-east-1',
'us-east-2',
'us-west-1'
]
for region in vars(args)['regions']:
if region not in supported_regions:
LOGGER.error('Supported regions are %s', supported_regions)
return(1)
exit_code = 0
if vars(args)['template']:
matches = list()
runner = cfnlint.Runner(
rules, vars(args)['template'], template, vars(args)['ignore_checks'],
vars(args)['regions'])
matches.extend(runner.run())
matches.sort(key=lambda x: (x.filename, x.linenumber, x.rule.id))
exit_code = len(matches)
if vars(args)['format'] == 'json':
print(json.dumps(matches, indent=4, cls=CustomEncoder))
else:
for match in matches:
print(formatter.format(match))
else:
parser.print_help()
return exit_code
def setUp(self):
"""Setup"""
self.collection = RulesCollection(include_rules=['I'])
