CH-157 refactor, docs, enhancements

Author: filippomc

application-templates/django-ninja/README.md

@@ -34,19 +34,29 @@ Frontend code is inside the *frontend* directory.
 
 Frontend is by default generated as a React web application, but no constraint about this specific technology.
 
-#### Call the backend apis
+See also [frontend/README.md]
+
+#### Generate API client stubs
 All the api stubs are automatically generated in the [frontend/rest](frontend/rest) directory by `harness-application`
 and `harness-generate`.
 
+To update frontend client stubs, run
+
+```
+harness-generate clients __APP_NAME__ -t
+```
+
+Stubs can also be updated using the `genapi.sh` from the api folder.
+
 ## Local build & run
 
-### Install dependencies 
+### Install Python dependencies 
 1 - Clone cloud-harness into your project root folder 
 
 2 - Run the dev setup script
 ```
 cd applications/__APP_NAME__
-bash dev-setup.sh
+source dev-setup.sh
 ```
 
 ### Prepare backend
@@ -62,25 +72,43 @@ cd static/www
 ln -s ../../../frontend/dist dist
 ```
 
-### Build frontend
+### Run frontend
 
-Compile the frontend
-```bash
-cd frontend
-npm install
-npm run build
-```
+- `yarn dev` Local dev with no backend (no or mock data, cookie required)
+- `yarn start` Local dev with backend on localhost:8000 -- see next paragraph (cookie required)
+- `yarn start:dev` Local dev with backend on the remote dev deployment  (cookie required)
+- `yarn start:local` Local dev with backend on the local dev deployment on mnp.local (cookie required)
+
+To obtain the login cookie, login in the application with the forwarded backend, copy the `kc-access` cookie and set it into localhost:9000
 
 ### Run backend application
 
 start the Django server
+
 ```bash
-uvicorn --workers 2 --host 0.0.0.0 --port 8000 django_baseapp.asgi:application
+ACCOUNTS_ADMIN_PASSWORD=metacell ACCOUNTS_ADMIN_USERNAME=admin CH_CURRENT_APP_NAME=__APP_NAME__ CH_VALUES_PATH=../../../deployment/helm/values.yaml DJANGO_SETTINGS_MODULE=django_baseapp.settings KUBERNETES_SERVICE_HOST=a uvicorn --host 0.0.0.0 --port 8000 django_baseapp.asgi:application
 ```
 
+Before running this backend, have to:
+- Run `harness-deployment ... -n [NAMESPACE] -i __APP_NAME__` with the setup 
+- port-forward keycloak and the database (see below)
 
 ### Running local with port forwardings to a kubernetes cluster
 When you create port forwards to microservices in your k8s cluster you want to forced your local backend server to initialize
 the AuthService and EventService services.
 This can be done by setting the `KUBERNETES_SERVICE_HOST` environment variable to a dummy or correct k8s service host.
 The `KUBERNETES_SERVICE_HOST` switch will activate the creation of the keycloak client and client roles of this microservice.
+
+Run `port-forward.sh` to get the keycloak and database running.
+
+To access those have to map to the hosts file:
+
+```
+127.0.0.1 accounts.[NAMESPACE] __APP_NAME__-db
+```
+
+After running the backend on port 8000, run `yarn start` to get a frontend to it
+
+#### Vs code run configuration
+
+Run configuration is automatically generated for VS code (__APP_NAME__ backend)

application-templates/django-ninja/port-forward.sh

@@ -0,0 +1,6 @@
+fuser -k 5432/tcp
+fuser -k 8080/tcp
+namespace=${1:-ch}
+echo "Port forwarding for $namespace"
+kubectl port-forward --namespace $namespace deployment/accounts 8080:8080 &
+kubectl port-forward --namespace $namespace deployment/__APP_NAME__-db 5432:5432 &

application-templates/webapp/frontend/package.json

@@ -3,8 +3,8 @@
   "scripts": {
     "dev": "vite",
     "start": "DOMAIN=http://localhost:5000 vite",
-    "start:dev": "DOMAIN=https://test.ch.metacell.us vite",
-    "start:local": "DOMAIN=http://samples.ch vite",
+    "start:dev": "DOMAIN=https://__APP_NAME__.ch.metacell.us vite",
+    "start:local": "DOMAIN=http://__APP_NAME__.ch vite",
     "prebuild": "eslint .",
     "build": "vite build",
     "lint": "eslint src --report-unused-disable-directives --fix"

application-templates/webapp/frontend/src/components/RestTest.tsx

@@ -1,19 +1,19 @@
 import { useState, useEffect } from 'react';
 
 
-import { TestApi } from '../rest/apis/TestApi'
+import { TestApi } from '../rest/__APP_NAME__/apis/TestApi'
 const test = new TestApi();
 
 
 
 const RestTest = () => {
   const [result, setResult] = useState<any>(null);
   useEffect(() => {
-    test.ping().then((r) => setResult(r), () => setResult( "API error"));
+    test.ping().then((r) => setResult(r), () => setResult("API error"));
   }, []);
-    
 
-  return result ? <p>Backend answered: { result } </p> : <p>Backend did not answer</p>
+
+  return result ? <p>Backend answered: {result} </p> : <p>Backend did not answer</p>
 }
 
 export default RestTest;

infrastructure/common-images/cloudharness-django/libraries/cloudharness-django/cloudharness_django/settings.py

@@ -50,7 +50,7 @@
 except:
     # no current app found, fall back to the default settings, there is a god change that
     # we are running on a developers local machine
-    log.warning("Error setting current app configuration, continuing...")
+    log.warning("Error setting current app configuration, was `harness-deployment` executed? Continuing...")
 
     current_app = applications.ApplicationConfiguration({
         "name": app_name,

libraries/client/cloudharness_cli/cloudharness_cli/__init__.py

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+"""
+    ninjatest API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import unittest
+
+from cloudharness_cli.ninjatest.api.test_api import TestApi
+
+
+class TestTestApi(unittest.TestCase):
+    """TestApi unit test stubs"""
+
+    def setUp(self) -> None:
+        self.api = TestApi()
+
+    def tearDown(self) -> None:
+        pass
+
+    def test_ninjatest_api_live(self) -> None:
+        """Test case for ninjatest_api_live
+
+        Live
+        """
+        pass
+
+    def test_ninjatest_api_ping(self) -> None:
+        """Test case for ninjatest_api_ping
+
+        Ping
+        """
+        pass
+
+    def test_ninjatest_api_ready(self) -> None:
+        """Test case for ninjatest_api_ready
+
+        Ready
+        """
+        pass
+
+
+if __name__ == '__main__':
+    unittest.main()

libraries/client/cloudharness_cli/test/ninjatest/__init__.py

@@ -89,7 +89,7 @@ def handle_post_merge(self):
         logging.info('Installing frontend dependencies')
         self.install_frontend_dependencies()
         logging.info('Generating ts client')
-        generate_ts_client(self.api_path / 'openapi.yaml')
+        generate_ts_client(self.api_path / 'openapi.yaml', self.app_name)
 
     def create_vite_skaffold(self, frontend_path: pathlib.Path) -> None:
         self.run_command(

libraries/client/cloudharness_cli/test/ninjatest/test_test_api.py

@@ -17,7 +17,7 @@
 from ch_cli_tools.manifest import get_manifest
 
 from . import HERE
-from .utils import copymergedir, replaceindir, to_python_module
+from .utils import confirm, copymergedir, replace_in_file, replaceindir, to_python_module
 
 CODEGEN = os.path.join(HERE, 'bin', 'openapi-generator-cli.jar')
 APPLICATIONS_SRC_PATH = os.path.join('applications')
@@ -129,33 +129,60 @@ def generate_python_client(module, openapi_file, client_src_path, lib_name=LIB_N
     os.system(command)
 
 
-def generate_ts_client(openapi_file):
+def generate_ts_client(openapi_file, app_name=""):
     get_dependencies()
-    out_dir = f"{os.path.dirname(os.path.dirname(openapi_file))}/frontend/src/rest"
+    out_dir = f"{os.path.dirname(os.path.dirname(openapi_file))}/frontend/src/rest/{app_name}"
     command = f"java -jar {CODEGEN} generate " \
         f"-i {openapi_file} " \
         f"-g typescript-fetch " \
-        f"-o {out_dir}"
+        f"-o {out_dir} "\
+        f"--additional-properties=prefixParameterInterfaces=false"
     os.system(command)
 
     replaceindir(out_dir, "http://localhost", '')
 
 
+def json2yaml(json_filename, yaml_file=None):
+    import yaml
+    if yaml_file is None:
+        yaml_file = str(json_filename).replace('.json', '.yaml')
+    with open(json_filename, 'r') as json_filename:
+        data = json.load(json_filename)
+        with open(yaml_file, 'w') as yaml_file:
+            yaml.dump(data, yaml_file)
+
+
 def generate_openapi_from_ninja_schema(app_name: str, app_path: pathlib.Path) -> None:
-    subprocess.check_call(["sh", "dev-setup.sh"], cwd=app_path)
-    out_path = app_path / 'api' / 'openapi.yaml'
+    # check if cloudharness_django python library is installed
+    python_module = to_python_module(app_name)
+    try:
+        import cloudharness_django
+        # dynamicall import python_module
+        __import__(f'{python_module}')
+    except ImportError:
+        if confirm('Runtime env is not installed. Do you want to install it? [Y/n]'):
+            subprocess.check_call(["sh", "dev-setup.sh"], cwd=app_path)
+        else:
+            logging.error('Runtime env is not installed. Cound not generate openapi files for Django Ninja.')
+            return
+    logging.info(f"Generating openapi files for Django Ninja for application {app_name}")
+    out_path = app_path / 'api' / 'openapi.json'
 
     manage_path = app_path / 'backend' / 'manage.py'
     command = [
         'python', manage_path, 'export_openapi_schema',
         '--settings', 'django_baseapp.settings',
-        '--api', f'{to_python_module(app_name)}.api.api',
+        '--api', f'{python_module}.api.api',
         '--output', out_path,
         '--indent', '2',
     ]
 
     subprocess.run(command)
 
+    replace_in_file(out_path, f'{app_name}_api_', '')
+
+    json2yaml(out_path)
+
 
 def get_dependencies():
     """
@@ -235,6 +262,8 @@ def generate_clients(
     if not should_generate('client libraries'):
         return
 
+    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())
@@ -253,7 +282,7 @@ def generate_clients(
                 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)
+                generate_ts_client(openapi_file, app_name)
 
     aggregate_packages(client_src_path, client_lib_name)