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")