small refactoring for harness-generate

Author: ddelpiano

tools/deployment-cli-tools/ch_cli_tools/openapi.py

@@ -17,7 +17,7 @@
 from ch_cli_tools.manifest import get_manifest
 
 from . import HERE
-from .utils import confirm, copymergedir, replace_in_file, replaceindir, to_python_module
+from .utils import confirm, copymergedir, replace_in_file, replaceindir, to_python_module, get_apps_paths
 
 CODEGEN = os.path.join(HERE, 'bin', 'openapi-generator-cli.jar')
 APPLICATIONS_SRC_PATH = os.path.join('applications')
@@ -39,24 +39,27 @@ def all(cls):
 def generate_flask_server(app_path: pathlib.Path, overrides_folder: Optional[pathlib.Path] = None) -> None:
     get_dependencies()
 
-    openapi_directory = app_path / 'api'
-    openapi_file = next(openapi_directory.glob('*.yaml'))
-
-    server_path = app_path / 'server'
-    backend_path = app_path / 'backend'
-    out_path = server_path if server_path.exists() else backend_path
-
-    command = [
-        'java', '-jar', CODEGEN, 'generate',
-        '-i', openapi_file,
-        '-g', 'python-flask',
-        '-o', out_path,
-        '-c', openapi_directory / 'config.json',
-    ]
-    if overrides_folder:
-        command += ['-t', overrides_folder]
-
-    subprocess.run(command)
+    try:
+        openapi_directory = app_path / 'api'
+        openapi_file = next(openapi_directory.glob('*.yaml'))
+
+        server_path = app_path / 'server'
+        backend_path = app_path / 'backend'
+        out_path = server_path if server_path.exists() else backend_path
+
+        command = [
+            'java', '-jar', CODEGEN, 'generate',
+            '-i', openapi_file,
+            '-g', 'python-flask',
+            '-o', out_path,
+            '-c', openapi_directory / 'config.json',
+        ]
+        if overrides_folder:
+            command += ['-t', overrides_folder]
+
+        subprocess.run(command)
+    except:
+        logging.error(f'An error occurred while generating the server stubs for {app_path.name}', exc_info=True)
 
 
 def generate_fastapi_server(app_path: pathlib.Path) -> None:
@@ -230,16 +233,12 @@ def generate_servers(
     """
     Generates server stubs
     """
-    openapi_files = [path for path in root_path.glob('applications/*/api/*.yaml')]
+    apps_path = get_apps_paths(root_path, app_name)
 
-    for openapi_file in openapi_files:
-        app_path = openapi_file.parent.parent
+    for app_path in apps_path:
         manifest = get_manifest(app_path)
 
-        if app_name and manifest.app_name != app_name:
-            continue
-
-        if not should_generate(f'server stubs for {openapi_file}'):
+        if not should_generate(f'Should we regenerate the server stubs for {app_path.name} ?'):
             continue
 
         if TemplateType.DJANGO_FASTAPI in manifest.templates:
@@ -259,32 +258,32 @@ def generate_clients(
     """
     Generates client stubs
     """
-    if not should_generate('client libraries'):
-        return
+    apps_path = get_apps_paths(root_path, app_name)
 
     logging.info('Generating client libraries for %s', str(client_types))
 
-    client_src_path = root_path / 'libraries' / 'client' / client_lib_name
-    apps_path = root_path / 'applications'
-    apps = (app for app in apps_path.iterdir() if app.is_dir())
+    if client_lib_name:
+        client_src_path = root_path / 'libraries' / 'client' / client_lib_name
 
-    for app_path in apps:
+    for app_path in apps_path:
         manifest = get_manifest(app_path)
 
-        if app_name and manifest.app_name != app_name:
+        if not should_generate(f'Should we regenerate the client libraries for {app_path.name} ?'):
             continue
 
         if TemplateType.DJANGO_NINJA in manifest.templates:
             generate_openapi_from_ninja_schema(manifest.app_name, app_path)
 
         for openapi_file in app_path.glob('api/*.yaml'):
-            if ClientType.PYTHON_CLIENT in client_types:
+            if ClientType.PYTHON_CLIENT in client_types and client_lib_name:
                 generate_python_client(manifest.app_name, openapi_file, client_src_path, lib_name=client_lib_name)
 
             if TemplateType.WEBAPP in manifest.templates and ClientType.TS_CLIENT in client_types:
-                generate_ts_client(openapi_file, app_name)
+                ts_client_name = app_name if app_name else manifest.app_name
+                generate_ts_client(openapi_file, ts_client_name)
 
-    aggregate_packages(client_src_path, client_lib_name)
+    if client_lib_name:
+        aggregate_packages(client_src_path, client_lib_name)
 
 
 def aggregate_packages(client_source_path: pathlib.Path, lib_name=LIB_NAME):

tools/deployment-cli-tools/ch_cli_tools/utils.py

@@ -490,3 +490,15 @@ def load_yaml(yaml_file: pathlib.Path) -> dict:
 def save_yaml(yaml_file: pathlib.Path, data: dict) -> None:
     with yaml_file.open('w') as file:
         yaml.dump(data, file)
+
+
+def get_apps_paths(root, app_name) -> tuple[str]:
+    apps_path = []
+
+    if app_name:
+        logging.info('### Generating server stubs for %s ###', app_name)
+        apps_path = [path for path in root.glob(f'applications/{app_name}') if path.is_dir()]
+    else:
+        logging.info('### Generating server stubs for all applications ###')
+        apps_path = [path for path in root.glob('applications/*') if path.is_dir()]
+    return apps_path

tools/deployment-cli-tools/harness-generate

@@ -17,7 +17,10 @@ def main():
     args = get_command_line_arguments()
     get_dependencies()
 
-    root_path = args.path.absolute()
+    root_path = args.path.absolute() if args.path else pathlib.Path.cwd().absolute()
+    app_name = root_path.name if args.path else args.app_name
+    if args.path and args.app_name:
+        logging.warning('Ignoring app_name flag because path was provided')
 
     # Check if applications folder exists, if not, go up until it's found
     while not (root_path / 'applications').exists():
@@ -32,11 +35,10 @@ def main():
         generate_models(root_path, should_generate)
 
     if args.generate_servers:
-        generate_servers(root_path, should_generate, args.app_name)
+        generate_servers(root_path, should_generate, app_name)
 
     if args.generate_clients:
-        assert args.client_name is not None
-        generate_clients(root_path, should_generate, args.app_name, args.client_name, args.client_types)
+        generate_clients(root_path, should_generate, app_name, args.client_name, args.client_types)
 
 
 class GenerationMode(enum.Flag):
@@ -46,7 +48,7 @@ class GenerationMode(enum.Flag):
 
     @classmethod
     def all(cls):
-        return functools.reduce(operator.or_, cls)
+        return functools.reduce(operator.or_, [cls.CLIENTS, cls.SERVERS])
 
 
 @dataclass(frozen=True)
@@ -72,18 +74,18 @@ class CommandLineArguments:
 
 
 def get_command_line_arguments() -> CommandLineArguments:
-    parser = argparse.ArgumentParser(description='Walks filesystem inside ./applications to create and update application scaffolding based on API specifications.')
+    parser = argparse.ArgumentParser(description='Walks the filesystem inside the ./applications folder to create and update applications scaffolding.')
 
     common_arguments = argparse.ArgumentParser(add_help=False)
-    common_arguments.add_argument('path', metavar='path', nargs='?', default=pathlib.Path.cwd(), type=pathlib.Path,
-                                  help='Base path of the application.')
+    common_arguments.add_argument('path', metavar='path', nargs='?', default=None, type=pathlib.Path,
+                                  help='Base path of the application. If used, the -a/--app_name flag is ignored.')
     common_arguments.add_argument('-i', '--interactive', dest='is_interactive', action="store_true",
                                   help='Asks before generate')
     common_arguments.add_argument('-a', '--app-name', dest='app_name', action="store", default=None,
                                   help='Generate only for a specific application')
 
     clients_arguments = argparse.ArgumentParser(add_help=False)
-    clients_arguments.add_argument('-cn', '--client-name', dest='client_name', action='store', default=LIB_NAME,
+    clients_arguments.add_argument('-cn', '--client-name', dest='client_name', action='store', default=None,
                                    help='specify client prefix name')
     client_type_group = clients_arguments.add_mutually_exclusive_group(required=False)
     client_type_group.add_argument('-t', '--ts-only', dest='client_types', action='store_const', const=ClientType.TS_CLIENT,
@@ -95,20 +97,20 @@ def get_command_line_arguments() -> CommandLineArguments:
     subparsers = parser.add_subparsers(title='generation modes', required=True)
 
     all_parser = subparsers.add_parser('all', parents=[common_arguments, clients_arguments],
-                                       help='Generate models, server stubs and client libraries')
+                                       help='Generate server stubs and client libraries')
     all_parser.set_defaults(generation_mode=GenerationMode.all())
 
-    models_parser = subparsers.add_parser('models', parents=[common_arguments],
-                                          help='Generate only model library')
-    models_parser.set_defaults(generation_mode=GenerationMode.MODELS)
+    clients_parser = subparsers.add_parser('clients', parents=[common_arguments, clients_arguments],
+                                           help='Generate only client libraries')
+    clients_parser.set_defaults(generation_mode=GenerationMode.CLIENTS)
 
     servers_parser = subparsers.add_parser('servers', parents=[common_arguments],
                                            help='Generate only server stubs')
     servers_parser.set_defaults(generation_mode=GenerationMode.SERVERS)
 
-    clients_parser = subparsers.add_parser('clients', parents=[common_arguments, clients_arguments],
-                                           help='Generate only client libraries')
-    clients_parser.set_defaults(generation_mode=GenerationMode.CLIENTS)
+    models_parser = subparsers.add_parser('models', parents=[common_arguments],
+                                          help='Special flag, used to regenerate only model libraries')
+    models_parser.set_defaults(generation_mode=GenerationMode.MODELS)
 
     args = parser.parse_args()