def generate(self, project):
LOG.debug("Generate started")
self._init_from_project(project)
models = resolve_models(project.schema)
if project.configuration_schema:
configuration_schema_path = (project.root /
project.configuration_schema_filename)
project.write_configuration_schema(configuration_schema_path)
configuration_models = resolve_models(project.configuration_schema,
"TypeConfigurationModel")
else:
configuration_models = {"TypeConfigurationModel": {}}
models.update(configuration_models)
path = self.package_root / self.package_name / "models.py"
LOG.debug("Writing file: %s", path)
template = self.env.get_template("models.py")
contents = template.render(support_lib_pkg=SUPPORT_LIB_PKG,
models=models)
project.overwrite(path, contents)
LOG.debug("Generate complete")
def generate(self, project):
LOG.debug("Generate started")
root = project.root / "cmd"
# project folder structure
src = root / "resource"
format_paths = []
LOG.debug("Writing Types")
models = resolve_models(project.schema)
template = self.env.get_template("types.go.tple")
path = src / "{}.go".format("model")
contents = template.render(models=models)
project.overwrite(path, contents)
format_paths.append(path)
path = root / "main.go"
LOG.debug("Writing project: %s", path)
template = self.env.get_template("main.go.tple")
importpath = Path(project.settings["importpath"])
contents = template.render(path=importpath / "cmd" / "resource")
project.overwrite(path, contents)
format_paths.append(path)
# named files must all be in one directory
for path in format_paths:
try:
subprocess_run(["go", "fmt", path], cwd=root, check=True)
except (FileNotFoundError, CalledProcessError) as e:
raise DownstreamError("go fmt failed") from e
def generate(self, project):
LOG.debug("Generate started")
root = project.root / "cmd"
# project folder structure
src = root / "resource"
format_paths = []
LOG.debug("Writing Types")
models = resolve_models(project.schema)
template = self.env.get_template("types.go.tple")
path = src / "{}.go".format("model")
contents = template.render(models=models)
project.overwrite(path, contents)
format_paths.append(path)
path = root / "main.go"
LOG.debug("Writing project: %s", path)
template = self.env.get_template("main.go.tple")
importpath = Path(project.settings["importpath"])
contents = template.render(path=importpath / "cmd" / "resource")
project.overwrite(path, contents)
format_paths.append(path)
# Makefile
path = project.root / "Makefile"
LOG.debug("Writing Makefile: %s", path)
template = self.env.get_template("Makefile")
contents = template.render()
project.overwrite(path, contents)
# named files must all be in one directory
for path in format_paths:
try:
subprocess_run(["go", "fmt", path],
cwd=root,
check=True,
capture_output=True)
except (FileNotFoundError, CalledProcessError) as e:
raise DownstreamError("go fmt failed") from e
# Update settings as needed
need_to_write = False
for key, new in DEFAULT_SETTINGS.items():
old = project.settings.get(key)
if project.settings.get(key) != new:
LOG.debug(f"{key} version change from {old} to {new}")
project.settings[key] = new
need_to_write = True
if key == "pluginVersion":
# Display any upgrade messages
print(*check_version(old), sep="\n")
if need_to_write:
project.write_settings()
def generate(self, project):
LOG.debug("Generate started")
self._init_from_project(project)
models = resolve_models(project.schema)
path = self.package_root / self.package_name / "models.py"
LOG.debug("Writing file: %s", path)
template = self.env.get_template("models.py")
contents = template.render(support_lib_pkg=SUPPORT_LIB_PKG, models=models)
project.overwrite(path, contents)
LOG.debug("Generate complete")
def generate(self, project):
LOG.debug("Generate started")
self._init_from_project(project)
models = resolve_models(project.schema)
path = self.package_root / "models.ts"
LOG.debug("Writing file: %s", path)
template = self.env.get_template("models.ts")
contents = template.render(
lib_name=SUPPORT_LIB_NAME,
type_name=project.type_name,
models=models,
primaryIdentifier=project.schema.get("primaryIdentifier", []),
additionalIdentifiers=project.schema.get("additionalIdentifiers",
[]),
)
project.overwrite(path, contents)
LOG.debug("Generate complete")
def test_resolve_models():
# want to avoid a complex test here, since it could hide missed
# cases in the more detailed tests
models = resolve_models({})
assert not models
def generate(self, project):
"""Generate"""
self._namespace_from_project(project)
# clean generated files
generated_root = self._get_generated_root(project)
LOG.debug("Removing generated sources: %s", generated_root)
shutil.rmtree(generated_root, ignore_errors=True)
generated_tests_root = self._get_generated_tests_root(project)
LOG.debug("Removing generated tests: %s", generated_tests_root)
shutil.rmtree(generated_tests_root, ignore_errors=True)
# create generated sources and tests directories
src = generated_root.joinpath(*self.namespace)
LOG.debug("Making generated folder structure: %s", src)
src.mkdir(parents=True, exist_ok=True)
test_src = generated_tests_root.joinpath(*self.namespace)
LOG.debug("Making generated tests folder structure: %s", test_src)
test_src.mkdir(parents=True, exist_ok=True)
# write generated handler integration with LambdaWrapper
path = src / "HandlerWrapper.java"
LOG.debug("Writing handler wrapper: %s", path)
template = self.env.get_template("generate/HandlerWrapper.java")
contents = template.render(
package_name=self.package_name,
operations=project.schema.get("handlers", {}).keys(),
pojo_name="ResourceModel",
wrapper_parent="LambdaWrapper",
)
project.overwrite(path, contents)
# write generated handler integration with ExecutableWrapper
self._write_executable_wrapper_class(src, project)
path = src / "BaseConfiguration.java"
LOG.debug("Writing base configuration: %s", path)
template = self.env.get_template("generate/BaseConfiguration.java")
contents = template.render(
package_name=self.package_name,
schema_file_name=project.schema_filename,
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
path = src / "BaseHandler.java"
LOG.debug("Writing base handler: %s", path)
template = self.env.get_template("generate/BaseHandler.java")
contents = template.render(
package_name=self.package_name,
operations=OPERATIONS,
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
# generate POJOs
models = resolve_models(project.schema)
LOG.debug("Writing %d POJOs", len(models))
base_template = self.env.get_template("generate/ResourceModel.java")
pojo_template = self.env.get_template("generate/POJO.java")
for model_name, properties in models.items():
path = src / "{}.java".format(model_name)
LOG.debug("%s POJO: %s", model_name, path)
if model_name == "ResourceModel":
contents = base_template.render(
type_name=project.type_name,
package_name=self.package_name,
model_name=model_name,
properties=properties,
primaryIdentifier=project.schema.get(
"primaryIdentifier", []),
additionalIdentifiers=project.schema.get(
"additionalIdentifiers", []),
)
else:
contents = pojo_template.render(
package_name=self.package_name,
model_name=model_name,
properties=properties,
)
project.overwrite(path, contents)
self._update_settings(project)
LOG.debug("Generate complete")
def generate_hook(self, src, project): # pylint: disable=too-many-statements
# write generated hook handler integration with HookLambdaWrapper
path = src / "HookHandlerWrapper.java"
LOG.debug("Writing hook handler wrapper: %s", path)
template = self.env.get_template(
"generate/hook/HookHandlerWrapper.java")
contents = template.render(
package_name=self.package_name,
operations=project.schema.get("handlers", {}).keys(),
wrapper_parent="HookLambdaWrapper",
)
project.overwrite(path, contents)
# write generated handler integration with HookExecutableWrapper
self._write_executable_wrapper_class(src, project)
path = src / "BaseHookHandler.java"
LOG.debug("Writing base hook handler: %s", path)
template = self.env.get_template("generate/hook/BaseHookHandler.java")
contents = template.render(package_name=self.package_name,
operations=HOOK_OPERATIONS)
project.overwrite(path, contents)
# generate POJOs
models = resolve_models(project.schema, "HookInputModel")
if project.configuration_schema:
configuration_schema_path = (self._get_generated_root(project) /
project.configuration_schema_filename)
project.write_configuration_schema(configuration_schema_path)
configuration_models = resolve_models(project.configuration_schema,
"TypeConfigurationModel")
else:
configuration_models = {"TypeConfigurationModel": {}}
models.update(configuration_models)
LOG.debug("Writing %d POJOs", len(models))
base_template = self.env.get_template(
"generate/hook/HookInputModel.java")
pojo_template = self.env.get_template("generate/POJO.java")
for model_name, properties in models.items():
path = src / "{}.java".format(model_name)
LOG.debug("%s POJO: %s", model_name, path)
if model_name == "HookInputModel": # pragma: no cover
contents = base_template.render(
type_name=project.type_name,
package_name=self.package_name,
model_name=model_name,
properties=properties,
)
else:
contents = pojo_template.render(
package_name=self.package_name,
model_name=model_name,
properties=properties,
no_args_constructor_required=(
model_name != "TypeConfigurationModel"
or len(properties) != 0),
)
project.overwrite(path, contents)
loaded_target_schema_file_names = {}
for target_type_name, target_info in project.target_info.items():
target_schema = target_info["Schema"]
target_namespace = [
s.lower() for s in target_type_name.split("::")
] # AWS::SQS::Queue -> awssqsqueue
target_name = "".join([s.capitalize() for s in target_namespace
]) # awssqsqueue -> AwsSqsQueue
target_schema_file_name = "{}.json".format("-".join(
target_namespace)) # awssqsqueue -> aws-sqs-queue.json
target_model_package_name = "{}.model.{}".format(
self.package_name, ".".join(target_namespace))
target_model_dir = (src / "model").joinpath(*target_namespace)
target_model_dir.mkdir(parents=True, exist_ok=True)
loaded_target_schemas_dir = (project.root / "target" /
"loaded-target-schemas")
loaded_target_schemas_dir.mkdir(parents=True, exist_ok=True)
if target_info.get("SchemaFileAvailable"): # pragma: no cover
contents = json.dumps(target_schema, indent=4)
path = loaded_target_schemas_dir / target_schema_file_name
project.overwrite(path, contents)
loaded_target_schema_file_names[
target_type_name] = target_schema_file_name
is_registry_type = target_info.get("IsCfnRegistrySupportedType")
if not target_schema:
target_schema = {
"typeName": target_name,
"properties": {},
"required": [],
"additionalProperties": False,
}
# generate POJOs
models = resolve_models(target_schema, target_name)
# TODO: Remove once tagging is fully supported
if models.get(target_name, {}).get("Tags"): # pragma: no cover
models[target_name]["Tags"] = ResolvedType(
ContainerType.PRIMITIVE, UNDEFINED)
LOG.debug("Writing %d POJOs", len(models))
base_template = self.env.get_template(
"generate/hook/ResourceHookTargetModel.java")
target_template = self.env.get_template(
"generate/hook/ResourceHookTarget.java")
pojo_template = self.env.get_template("generate/POJO.java")
for model_name, properties in models.items():
path = target_model_dir / "{}.java".format(model_name)
LOG.debug("%s POJO: %s", model_name, path)
if model_name == target_name:
contents = target_template.render(
type_name=target_type_name,
package_name=target_model_package_name,
model_name=target_name,
is_registry_type=is_registry_type,
schema_available=(target_info.get(
"SchemaFileAvailable", False)),
schema_path=loaded_target_schema_file_names.get(
target_type_name),
properties=properties,
primaryIdentifier=target_schema.get(
"primaryIdentifier", []),
additionalIdentifiers=target_schema.get(
"additionalIdentifiers", []),
)
else:
contents = pojo_template.render(
package_name=target_model_package_name,
model_name=model_name,
properties=properties,
no_args_constructor_required=(
model_name != "TypeConfigurationModel"
or len(properties) != 0),
)
project.overwrite(path, contents)
path = target_model_dir / "{}TargetModel.java".format(target_name)
contents = base_template.render(
type_name=target_type_name,
model_name=target_name,
package_name=target_model_package_name,
)
project.overwrite(path, contents)
path = src / "BaseHookConfiguration.java"
LOG.debug("Writing base hook configuration: %s", path)
template = self.env.get_template(
"generate/hook/BaseHookConfiguration.java")
contents = template.render(
package_name=self.package_name,
schema_file_name=project.schema_filename,
target_schema_paths=loaded_target_schema_file_names,
)
project.overwrite(path, contents)
self._update_settings(project)
LOG.debug("Generate complete")
def generate_resource(self, src, project):
# write generated resource handler integration with LambdaWrapper
path = src / "HandlerWrapper.java"
LOG.debug("Writing handler wrapper: %s", path)
template = self.env.get_template("generate/HandlerWrapper.java")
contents = template.render(
package_name=self.package_name,
operations=project.schema.get("handlers", {}).keys(),
contains_type_configuration=project.configuration_schema,
pojo_name="ResourceModel",
wrapper_parent="LambdaWrapper",
)
project.overwrite(path, contents)
# write generated handler integration with ExecutableWrapper
self._write_executable_wrapper_class(src, project)
path = src / "BaseConfiguration.java"
LOG.debug("Writing base configuration: %s", path)
template = self.env.get_template("generate/BaseConfiguration.java")
contents = template.render(
package_name=self.package_name,
schema_file_name=project.schema_filename,
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
path = src / "BaseHandler.java"
LOG.debug("Writing base handler: %s", path)
template = self.env.get_template("generate/BaseHandler.java")
contents = template.render(
package_name=self.package_name,
operations=RESOURCE_OPERATIONS,
contains_type_configuration=project.configuration_schema,
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
# generate POJOs
models = resolve_models(project.schema)
if project.configuration_schema:
configuration_schema_path = (self._get_generated_root(project) /
project.configuration_schema_filename)
project.write_configuration_schema(configuration_schema_path)
configuration_models = resolve_models(project.configuration_schema,
"TypeConfigurationModel")
else:
configuration_models = {"TypeConfigurationModel": {}}
models.update(configuration_models)
LOG.debug("Writing %d POJOs", len(models))
base_template = self.env.get_template("generate/ResourceModel.java")
pojo_template = self.env.get_template("generate/POJO.java")
for model_name, properties in models.items():
path = src / "{}.java".format(model_name)
LOG.debug("%s POJO: %s", model_name, path)
if model_name == "ResourceModel":
contents = base_template.render(
type_name=project.type_name,
package_name=self.package_name,
model_name=model_name,
properties=properties,
primaryIdentifier=project.schema.get(
"primaryIdentifier", []),
additionalIdentifiers=project.schema.get(
"additionalIdentifiers", []),
)
else:
contents = pojo_template.render(
package_name=self.package_name,
model_name=model_name,
properties=properties,
no_args_constructor_required=(
model_name != "TypeConfigurationModel"
or len(properties) != 0),
)
project.overwrite(path, contents)
self._update_settings(project)
LOG.debug("Generate complete")
def generate(self, project):
"""Generate"""
self._namespace_from_project(project)
# clean generated files
generated_root = self._get_generated_root(project)
LOG.debug("Removing generated sources: %s", generated_root)
shutil.rmtree(generated_root, ignore_errors=True)
generated_tests_root = self._get_generated_tests_root(project)
LOG.debug("Removing generated tests: %s", generated_tests_root)
shutil.rmtree(generated_tests_root, ignore_errors=True)
# create generated sources and tests directories
src = generated_root.joinpath(*self.namespace)
LOG.debug("Making generated folder structure: %s", src)
src.mkdir(parents=True, exist_ok=True)
test_src = generated_tests_root.joinpath(*self.namespace)
LOG.debug("Making generated tests folder structure: %s", test_src)
test_src.mkdir(parents=True, exist_ok=True)
# write generated handler integration with LambdaWrapper
path = src / "HandlerWrapper.java"
LOG.debug("Writing handler wrapper: %s", path)
template = self.env.get_template("generate/HandlerWrapper.java")
contents = template.render(
package_name=self.package_name,
operations=project.schema.get("handlers", {}).keys(),
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
path = src / "BaseConfiguration.java"
LOG.debug("Writing base configuration: %s", path)
template = self.env.get_template("generate/BaseConfiguration.java")
contents = template.render(
package_name=self.package_name,
schema_file_name=project.schema_filename,
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
path = src / "BaseHandler.java"
LOG.debug("Writing base handler: %s", path)
template = self.env.get_template("generate/BaseHandler.java")
contents = template.render(
package_name=self.package_name,
operations=OPERATIONS,
pojo_name="ResourceModel",
)
project.overwrite(path, contents)
# generate POJOs
models = resolve_models(project.schema)
LOG.debug("Writing %d POJOs", len(models))
base_template = self.env.get_template("generate/ResourceModel.java")
pojo_template = self.env.get_template("generate/POJO.java")
for model_name, properties in models.items():
path = src / "{}.java".format(model_name)
LOG.debug("%s POJO: %s", model_name, path)
if model_name == "ResourceModel":
contents = base_template.render(
type_name=project.type_name,
package_name=self.package_name,
model_name=model_name,
properties=properties,
primaryIdentifier=project.schema.get(
"primaryIdentifier", []),
additionalIdentifiers=project.schema.get(
"additionalIdentifiers", []),
)
else:
contents = pojo_template.render(
package_name=self.package_name,
model_name=model_name,
properties=properties,
)
project.overwrite(path, contents)
# Update settings
java_plugin_dependency_version = self._get_java_plugin_dependency_version(
project)
if java_plugin_dependency_version < MINIMUM_JAVA_DEPENDENCY_VERSION:
raise JavaPluginVersionNotSupportedError(
"'aws-cloudformation-rpdk-java-plugin' {} is no longer supported."
"Please update it in pom.xml to version {} or above.".format(
java_plugin_dependency_version,
MINIMUM_JAVA_DEPENDENCY_VERSION))
protocol_version = project.settings.get(PROTOCOL_VERSION_SETTING)
if protocol_version != DEFAULT_PROTOCOL_VERSION:
project.settings[
PROTOCOL_VERSION_SETTING] = DEFAULT_PROTOCOL_VERSION
project.write_settings()
LOG.debug("Generate complete")
