def test_element_doc(self):
class A(object):
pass
class B(object):
"""Hello World
xyz
"""
class C(B):
pass
class D(ValueFilter):
pass
class E(ValueFilter):
"""Something"""
class F(D):
pass
class G(E):
pass
self.assertEqual(ElementSchema.doc(G), "Something")
self.assertEqual(ElementSchema.doc(D), "")
self.assertEqual(ElementSchema.doc(F), "")
self.assertEqual(
ElementSchema.doc(B), "Hello World\n\nxyz")
def _print_cls_schema(cls):
# Print docstring
docstring = ElementSchema.doc(cls)
print("\nHelp\n----\n")
if docstring:
print(docstring)
else:
# Shouldn't ever hit this, so exclude from cover
print("No help is available for this item.") # pragma: no cover
# Print schema
print("\nSchema\n------\n")
if hasattr(cls, 'schema'):
definitions = generate()['definitions']
component_schema = ElementSchema.schema(definitions, cls)
print(yaml_dump(component_schema))
else:
# Shouldn't ever hit this, so exclude from cover
print("No schema is available for this item.", file=sys.sterr) # pragma: no cover
print('')
return
def get_doc_examples(resources):
policies = []
seen = set()
for resource_name, v in resources.items():
for k, cls in itertools.chain(v.filter_registry.items(), v.action_registry.items()):
if cls in seen:
continue
seen.add(cls)
doc = ElementSchema.doc(cls)
if not doc:
continue
# split on yaml and new lines
split_doc = [x.split('\n\n') for x in doc.split('yaml')]
for item in itertools.chain.from_iterable(split_doc):
if 'policies:\n' in item:
policies.append((item, resource_name, cls.type))
elif 'resource:' in item:
item = 'policies:\n' + item
policies.append((item, resource_name, cls.type))
return policies
def schema_cmd(options):
""" Print info about the resources, actions and filters available. """
from c7n import schema
if options.json:
schema.json_dump(options.resource)
return
if options.summary:
load_available()
resource_mapping = schema.resource_vocabulary()
schema.pprint_schema_summary(resource_mapping)
return
# Here are the formats for what we accept:
# - No argument
# - List all available RESOURCES
# - PROVIDER
# - List all available RESOURCES for supplied PROVIDER
# - RESOURCE
# - List all available actions and filters for supplied RESOURCE
# - MODE
# - List all available MODES
# - RESOURCE.actions
# - List all available actions for supplied RESOURCE
# - RESOURCE.actions.ACTION
# - Show class doc string and schema for supplied action
# - RESOURCE.filters
# - List all available filters for supplied RESOURCE
# - RESOURCE.filters.FILTER
# - Show class doc string and schema for supplied filter
if not options.resource:
load_available(resources=False)
resource_list = {'resources': sorted(itertools.chain(
*[clouds[p].resource_map.keys() for p in PROVIDER_NAMES]))}
print(yaml_dump(resource_list))
return
# Format is [PROVIDER].RESOURCE.CATEGORY.ITEM
# optional provider defaults to aws for compatibility
components = options.resource.lower().split('.')
if len(components) == 1 and components[0] in PROVIDER_NAMES:
load_providers((components[0]))
resource_list = {'resources': sorted(
clouds[components[0]].resource_map.keys())}
print(yaml_dump(resource_list))
return
if components[0] in PROVIDER_NAMES:
cloud_provider = components.pop(0)
components[0] = '%s.%s' % (cloud_provider, components[0])
load_resources((components[0],))
resource_mapping = schema.resource_vocabulary(
cloud_provider)
elif components[0] == 'mode':
load_available(resources=False)
resource_mapping = schema.resource_vocabulary()
else: # compatibility, aws is default for provider
components[0] = 'aws.%s' % components[0]
load_resources((components[0],))
resource_mapping = schema.resource_vocabulary('aws')
#
# Handle mode
#
if components[0] == "mode":
if len(components) == 1:
output = {components[0]: list(resource_mapping[components[0]].keys())}
print(yaml_dump(output))
return
if len(components) == 2:
if components[1] not in resource_mapping[components[0]]:
log.error('{} is not a valid mode'.format(components[1]))
sys.exit(1)
_print_cls_schema(resource_mapping[components[0]][components[1]])
return
# We received too much (e.g. mode.actions.foo)
log.error("Invalid selector '{}'. Valid options are 'mode' "
"or 'mode.TYPE'".format(options.resource))
sys.exit(1)
#
# Handle resource
#
resource = components[0]
if resource not in resource_mapping:
log.error('{} is not a valid resource'.format(resource))
sys.exit(1)
if len(components) == 1:
docstring = ElementSchema.doc(
resource_mapping[resource]['classes']['resource'])
del(resource_mapping[resource]['classes'])
if docstring:
print("\nHelp\n----\n")
print(docstring + '\n')
output = {resource: resource_mapping[resource]}
print(yaml_dump(output))
return
#
# Handle category
#
category = components[1]
if category not in ('actions', 'filters'):
log.error("Valid choices are 'actions' and 'filters'. You supplied '{}'".format(category))
sys.exit(1)
if len(components) == 2:
output = "No {} available for resource {}.".format(category, resource)
if category in resource_mapping[resource]:
output = {resource: {
category: resource_mapping[resource][category]}}
print(yaml_dump(output))
return
#
# Handle item
#
item = components[2]
if item not in resource_mapping[resource][category]:
log.error('{} is not in the {} list for resource {}'.format(item, category, resource))
sys.exit(1)
if len(components) == 3:
cls = resource_mapping[resource]['classes'][category][item]
_print_cls_schema(cls)
return
# We received too much (e.g. s3.actions.foo.bar)
log.error("Invalid selector '{}'. Max of 3 components in the "
"format RESOURCE.CATEGORY.ITEM".format(options.resource))
sys.exit(1)