[STU-337] Cloud integration: Loading test profile

captain/main.py

@@ -6,7 +6,7 @@
     devices,
     flowchart,
     key,
-    update,
+    test_profile,
     ws,
     log,
     test_sequence,
@@ -42,7 +42,7 @@ async def startup_event(app: FastAPI):
 app.include_router(flowchart.router)
 app.include_router(log.router)
 app.include_router(key.router)
-app.include_router(update.router)
+app.include_router(test_profile.router)
 app.include_router(blocks.router)
 app.include_router(devices.router)
 app.include_router(test_sequence.router)

captain/routes/cloud.py

@@ -136,7 +136,7 @@ class Unit(CloudModel):
     part_variation_id: str = Field(..., alias="partVariationId")
 
 
-class Measurement(CloudModel):
+class Measurement(BaseModel):
     test_id: str = Field(..., alias="testId")
     sequence_name: str = Field(..., alias="sequenceName")
     cycle_number: int = Field(..., alias="cycleNumber")
@@ -145,8 +145,8 @@ class Measurement(CloudModel):
     completion_time: float = Field(..., alias="completionTime")
 
 
-class Session(CloudModel):
-    serial_number: str
+class Session(BaseModel):
+    serial_number: str = Field(..., alias="serialNumber")
     station_id: str = Field(..., alias="stationId")
     integrity: bool
     aborted: bool
@@ -221,6 +221,7 @@ async def get_cloud_projects():
                     "label": p.name,
                     "value": p.id,
                     "part": part_var.model_dump(by_alias=True),
+                    "repoUrl": p.repo_url,
                     "productName": part.product_name,
                 }
             )

captain/routes/test_profile.py

@@ -0,0 +1,138 @@
+import logging
+import traceback
+import subprocess
+from typing import Annotated
+from fastapi import APIRouter, Header, Response
+import os
+import json
+from captain.utils.blocks_path import get_flojoy_dir
+
+
+router = APIRouter(tags=["test_profile"])
+
+
+@router.get("/test_profile/install/")
+async def install(url: Annotated[str, Header()]):
+    """
+    Download a git repo to the local machine if it's doesn't exist + verify its state
+    - Currently done for Github. (infer that the repo doesn't contain space)
+    - Private repo is not (directly) supported
+    TODO:
+    - [ ] Backup if git is not install on the system
+    """
+    try:
+        logging.info(f"Installing the profile from the url: {url}")
+        verify_git_install()
+        profiles_path = get_profiles_dir()
+        profile_path = get_profile_path_from_url(profiles_path, url)
+
+        # Find the profile
+        if not os.path.exists(profile_path):
+            # Clone the repo if it doesn't exist
+            cmd = ["git", "clone", "--depth", "1", url, profile_path]
+            res = subprocess.run(cmd, capture_output=True)
+            if res.returncode != 0:
+                stdout = res.stdout.decode("utf-8").strip()
+                stderr = res.stderr.decode("utf-8").strip()
+                logging.error(f"Error while cloning url: {stdout} - {stderr}")
+                raise Exception(f"Not able to clone {url} - Error: {res.returncode}")
+        else:
+            update_to_origin_main(profile_path)
+
+        commit_hash = get_commit_hash(profile_path)
+        profile_path = profile_path.replace(os.sep, "/")
+        return Response(
+            status_code=200,
+            content=json.dumps({"profile_root": profile_path, "hash": commit_hash}),
+        )
+    except Exception as e:
+        logging.error(f"Exception occured while installing {url}: {e}")
+        logging.error(traceback.format_exc())
+        Response(status_code=500, content=json.dumps({"error": f"{e}"}))
+
+
+@router.post("/test_profile/checkout/{commit_hash}/")
+async def checkout(url: Annotated[str, Header()], commit_hash: str):
+    try:
+        logging.info(f"Swtiching to the commit: {commit_hash} for the profile: {url}")
+        verify_git_install()
+        profiles_path = get_profiles_dir()
+        profile_path = get_profile_path_from_url(profiles_path, url)
+        curr_commit_hash = get_commit_hash(profile_path)
+        if curr_commit_hash != commit_hash:
+            cmd = ["git", "-C", profile_path, "fetch", "--all"]
+            res = subprocess.run(cmd, capture_output=True)
+            if res.returncode != 0:
+                raise Exception(f"Not able to fetch the repo - Error: {res.returncode}")
+            cmd = ["git", "-C", profile_path, "checkout", commit_hash]
+            res = subprocess.run(cmd, capture_output=True)
+            if res.returncode != 0:
+                raise Exception(
+                    f"Not able to checkout the commit - Error: {res.returncode}"
+                )
+
+        commit_hash = get_commit_hash(profile_path)
+        return Response(
+            status_code=200,
+            content=json.dumps({"profile_root": profile_path, "hash": commit_hash}),
+        )
+    except Exception as e:
+        logging.error(f"Exception occured while installing {url}: {e}")
+        logging.error(traceback.format_exc())
+        Response(status_code=500, content=json.dumps({"error": f"{e}"}))
+
+
+# Helper functions ------------------------------------------------------------
+
+
+def get_profile_path_from_url(profiles_path: str, url: str):
+    profile_name = url.split("/")[-1].strip(".git")
+    logging.info(f"Profile name: {profile_name}")
+    profile_root = os.path.join(profiles_path, profile_name)
+    return profile_root
+
+
+def verify_git_install():
+    cmd = ["git", "--version"]
+    res = subprocess.run(cmd, capture_output=True)
+    if res.returncode != 0:
+        raise NotImplementedError("Git is not found on you system")
+
+
+def get_profiles_dir():
+    profiles_dir = os.path.join(get_flojoy_dir(), f"test_profiles{os.sep}")
+    if not os.path.exists(profiles_dir):
+        os.makedirs(profiles_dir)
+    return profiles_dir
+
+
+def get_commit_hash(profile_path: str):
+    cmd = ["git", "-C", profile_path, "rev-parse", "HEAD"]
+    res = subprocess.run(cmd, capture_output=True)
+    if res.returncode != 0:
+        raise Exception(
+            f"Not able to get the commit ID of the local branch - Error: {res.returncode}"
+        )
+    return res.stdout.strip().decode()
+
+
+def update_to_origin_main(profile_path: str):
+    logging.info("Updating the repo to the origin main")
+    cmd = ["git", "-C", profile_path, "status", "--porcelain"]
+    res = subprocess.run(cmd, capture_output=True)
+    if res.returncode != 0:
+        raise Exception(
+            f"Not able to check the status of the repo - Error: {res.returncode}"
+        )
+    if res.stdout.strip() != b"":
+        raise Exception(f"Repo is not clean - {res.stdout}")
+    cmd = ["git", "-C", profile_path, "fetch", "--all"]
+    res = subprocess.run(cmd, capture_output=True)
+    if res.returncode != 0:
+        raise Exception(f"Not able to fetch the repo - Error: {res.returncode}")
+    cmd = ["git", "-C", profile_path, "checkout", "origin/main"]
+    res = subprocess.run(cmd, capture_output=True)
+    if res.returncode != 0:
+        raise Exception(
+            f"Not able to checkout the remote origin main - Error: {res.returncode}"
+        )

src/api/index.ts

@@ -145,14 +145,14 @@ export default {
   ): Promise<{ filePath: string; fileContent: string }[] | undefined> =>
     ipcRenderer.invoke(API.openFilesPicker, allowedExtensions, title),
 
-  openAllFilesInFolderPicker: (
+  openAllFilesInFolder: (
+    folderPath: string,
     allowedExtensions: string[] = ["json"],
-    title: string = "Select Folder",
   ): Promise<{ filePath: string; fileContent: string }[] | undefined> =>
     ipcRenderer.invoke(
       API.openAllFilesInFolderPicker,
+      folderPath,
       allowedExtensions,
-      title,
     ),
 
   getFileContent: (filepath: string): Promise<string> =>

src/main/utils.ts

@@ -188,42 +188,33 @@ export const openFilesPicker = (
 
 export const openAllFilesInFolderPicker = (
   _,
+  folderPath: string,
   allowedExtensions: string[] = ["json"],
-  title: string = "Select Folder",
-): Promise<{ filePath: string; fileContent: string }[] | undefined> => {
-  // Return mutiple files or all file with the allowed extensions if a folder is selected
-  return dialog
-    .showOpenDialog(global.mainWindow, {
-      title: title,
-      properties: ["openDirectory"],
-    })
-    .then((selectedPaths) => {
-      if (
-        selectedPaths.filePaths.length === 1 &&
-        fs.lstatSync(selectedPaths.filePaths[0]).isDirectory()
-      ) {
-        // If a folder is selected, found all file with the allowed extensions from that folder
-        const folerPath = selectedPaths.filePaths[0];
-        const paths: string[] = [];
-        fs.readdirSync(folerPath, { withFileTypes: true }).forEach((dirent) => {
-          if (dirent.isFile()) {
-            const nameAndExt = dirent.name.split(".");
-            const ext = nameAndExt[nameAndExt.length - 1];
-            if (allowedExtensions.includes(ext)) {
-              paths.push(join(folerPath, dirent.name));
-            }
-          }
-        });
-        const files = paths.map((path) => {
-          return {
-            filePath: path.split(sep).join(posix.sep),
-            fileContent: fs.readFileSync(path, { encoding: "utf-8" }),
-          };
-        });
-        return files;
+): { filePath: string; fileContent: string }[] | undefined => {
+  // Return multiple files or all files with the allowed extensions if a folder is selected
+  if (fs.existsSync(folderPath) && fs.lstatSync(folderPath).isDirectory()) {
+    // If a folder is selected, find all files with the allowed extensions from that folder
+    const paths: string[] = [];
+    fs.readdirSync(folderPath, { withFileTypes: true }).forEach((dirent) => {
+      if (dirent.isFile()) {
+        const nameAndExt = dirent.name.split(".");
+        const ext = nameAndExt[nameAndExt.length - 1];
+        if (allowedExtensions.includes(ext)) {
+          paths.push(join(folderPath, dirent.name));
+        }
       }
-      return undefined;
     });
+    const files = paths.map((path) => {
+      return {
+        filePath: path.split(sep).join(posix.sep),
+        fileContent: fs.readFileSync(path, { encoding: "utf-8" }),
+      };
+    });
+    // Log the number of files found
+    return files;
+  }
+  // Log that folder doesn't exist or is not a directory
+  return undefined;
 };
 
 export const cleanup = async () => {