Add required changes from PR222 to enable benchmarking of java codes.

Author: mahlashrifi

.gitignore

@@ -182,3 +182,6 @@ cache
 # IntelliJ IDEA files
 .idea
 *.iml
+
+# Visual Studio Code files
+.vscode/

benchmarks/wrappers/openwhisk/java/Main.java

@@ -1,9 +1,13 @@
+import faas.App;
+import com.google.gson.Gson;
 import com.google.gson.JsonObject;
-import com.example.project.App ;
+import util.SessionBlob;
+import util.ShaSecurityProvider;
 import java.time.Instant;
 import java.time.Duration;
 import java.io.File;
 import java.io.IOException;
+//import jakarta.ws.rs.core.Response;
 
 
 public class Main {
@@ -15,12 +19,17 @@ public static JsonObject main(JsonObject args) {
         Gson gson = new Gson();
         App function = new App();
 
+        long start_nano = System.nanoTime();
+
         Instant begin = Instant.now();
         JsonObject result = function.handler(args);
         Instant end = Instant.now();
 
-        long computeTime = Duration.between(begin, end).toNanos() / 1000; // Convert nanoseconds to microseconds
+        long end_nano = System.nanoTime();
+
+        // long computeTime = Duration.between(begin, end).toNanos() / 1000; // Convert nanoseconds to microseconds
 
+        long computeTime = end_nano - start_nano;
         boolean isCold = false;
         String fileName = "/cold_run"; 
 
@@ -41,15 +50,13 @@ public static JsonObject main(JsonObject args) {
         String requestId = System.getenv("__OW_ACTIVATION_ID");  
 
         JsonObject jsonResult = new JsonObject();
-        jsonObject.put("begin", formattedBegin); 
-        jsonObject.put("end", formattedEnd);
-        jsonObject.put("request_id", "requestId");  
-        jsonObject.put("compute_time", computeTime);
-        jsonObject.put("is_cold", isCold);
-        jsonObject.put("result", result);
+        jsonResult.addProperty("begin", formattedBegin); 
+        jsonResult.addProperty("end", formattedEnd);
+        jsonResult.addProperty("request_id", requestId);  
+        jsonResult.addProperty("compute_time", computeTime);
+        jsonResult.addProperty("is_cold", isCold);
+        jsonResult.addProperty("result", result.toString());
         return jsonResult;
     }
-}
 
-        
-        
+}

dockerfiles/openwhisk/java/Dockerfile.function

@@ -2,7 +2,7 @@ ARG BASE_IMAGE
 FROM $BASE_IMAGE
 COPY . /function/
 
-RUN apt-get update && apt-get install -y maven
+# RUN apt-get update && apt-get install -y maven
 
-# Check if pom.xml exists before running Maven
-RUN if [ -f ./pom.xml ]; then mvn clean install; else echo "pom.xml not found, aborting build." && exit 1; fi
+# # Check if pom.xml exists before running Maven
+# RUN if [ -f ./pom.xml ]; then mvn clean install; else echo "pom.xml not found, aborting build." && exit 1; fi

sebs/benchmark.py

@@ -1,6 +1,7 @@
 import glob
 import hashlib
 import json
+import subprocess
 import os
 import shutil
 import subprocess
@@ -200,8 +201,9 @@ def hash_directory(directory: str, deployment: str, language: str):
         FILES = {
             "python": ["*.py", "requirements.txt*"],
             "nodejs": ["*.js", "package.json"],
+            "java": ["*.java", "pom.xml"],
         }
-        WRAPPERS = {"python": "*.py", "nodejs": "*.js"}
+        WRAPPERS = {"python": "*.py", "nodejs": "*.js", "java": "*.java"}
         NON_LANG_FILES = ["*.sh", "*.json"]
         selected_files = FILES[language] + NON_LANG_FILES
         for file_type in selected_files:
@@ -273,6 +275,28 @@ def copy_code(self, output_dir):
         if os.path.exists(nodejs_package_json):
             shutil.copy2(nodejs_package_json, os.path.join(output_dir, "package.json"))
 
+    #This is for making jar file and add it to docker directory
+    def add_java_output(self, code_dir):
+
+        if self.language_name == "java":
+
+            # Step 1: Move Main.java o src directory
+            src_dir = os.path.join(code_dir, "src", "main", "java")
+            if os.path.exists(code_dir):
+                main_java_path = os.path.join(code_dir, "Main.java")
+                if os.path.exists(main_java_path):
+                    shutil.move(main_java_path, src_dir)
+
+            # Step 2: Run mvn clean install
+            try:
+                # Navigate to the code directory where the pom.xml file is located
+                subprocess.run(['mvn', 'clean', 'install'], cwd=code_dir, check=True, text=True, capture_output=True)
+                print("Maven build successful!")
+            except subprocess.CalledProcessError as e:
+                print(f"Error during Maven build:\n{e.stdout}\n{e.stderr}")
+                return         
+           
+
     def add_benchmark_data(self, output_dir):
         cmd = "/bin/bash {benchmark_path}/init.sh {output_dir} false"
         paths = [
@@ -522,6 +546,7 @@ def build(
         self.copy_code(self._output_dir)
         self.add_benchmark_data(self._output_dir)
         self.add_deployment_files(self._output_dir)
+        self.add_java_output(self._output_dir)
         self.add_deployment_package(self._output_dir)
         self.install_dependencies(self._output_dir)
         self._code_location, self._code_size = deployment_build_step(

sebs/openwhisk/openwhisk.py

@@ -168,7 +168,7 @@ def build_base_image(
         )
 
         for fn in os.listdir(directory):
-            if fn not in ("index.js", "__main__.py", "Main.java"):
+            if fn not in ("index.js", "__main__.py"):
                 file = os.path.join(directory, fn)
                 shutil.move(file, build_dir)
 
@@ -214,24 +214,27 @@ def package_code(
         # to allow registration of function with OpenWhisk
         self.build_base_image(directory, language_name, language_version, benchmark, is_cached)
 
-        # We deploy Minio config in code package since this depends on local
-        # deployment - it cannnot be a part of Docker image
-        CONFIG_FILES = {
-            "python": ["__main__.py"],
-            "nodejs": ["index.js"],
-            "java": ["Main.java"],
-        }
-        package_config = CONFIG_FILES[language_name]
-
-        benchmark_archive = os.path.join(directory, f"{benchmark}.zip")
-        subprocess.run(
-            ["zip", benchmark_archive] + package_config, stdout=subprocess.DEVNULL, cwd=directory
-        )
-        self.logging.info(f"Created {benchmark_archive} archive")
-        bytes_size = os.path.getsize(benchmark_archive)
-        self.logging.info("Zip archive size {:2f} MB".format(bytes_size / 1024.0 / 1024.0))
-        return benchmark_archive, bytes_size
+        if language_name != 'java':
+            # We deploy Minio config in code package since this depends on local
+            # deployment - it cannnot be a part of Docker image
+            CONFIG_FILES = {
+                "python": ["__main__.py"],
+                "nodejs": ["index.js"],
+            }
+            package_config = CONFIG_FILES[language_name]
 
+            benchmark_archive = os.path.join(directory, f"{benchmark}.zip")
+            subprocess.run(
+                ["zip", benchmark_archive] + package_config, stdout=subprocess.DEVNULL, cwd=directory
+            )
+            self.logging.info(f"Created {benchmark_archive} archive")
+            bytes_size = os.path.getsize(benchmark_archive)
+            self.logging.info("Zip archive size {:2f} MB".format(bytes_size / 1024.0 / 1024.0))
+            return benchmark_archive, bytes_size
+        benchmark_jar = os.path.join(directory, "docker", "target", "benchmark-1.jar")
+        bytes_size = os.path.getsize(benchmark_jar)
+
+        return benchmark_jar, bytes_size
     def storage_arguments(self) -> List[str]:
         storage = cast(Minio, self.get_storage())
         return [
@@ -281,27 +284,32 @@ def create_function(self, code_package: Benchmark, func_name: str) -> "OpenWhisk
                         code_package.language_name,
                         code_package.language_version,
                     )
+                    run_arguments = [
+                                *self.get_wsk_cmd(),
+                                "action",
+                                "create",
+                                func_name,
+                                "--web",
+                                "true",
+                                "--docker",
+                                docker_image,
+                                "--memory",
+                                str(code_package.benchmark_config.memory),
+                                "--timeout",
+                                str(code_package.benchmark_config.timeout * 1000),
+                                *self.storage_arguments(),
+                                code_package.code_location,
+                            ]
+                    if code_package.language_name == 'java':               
+                        run_arguments.extend(["--main", "Main"])
+                    
                     subprocess.run(
-                        [
-                            *self.get_wsk_cmd(),
-                            "action",
-                            "create",
-                            func_name,
-                            "--web",
-                            "true",
-                            "--docker",
-                            docker_image,
-                            "--memory",
-                            str(code_package.benchmark_config.memory),
-                            "--timeout",
-                            str(code_package.benchmark_config.timeout * 1000),
-                            *self.storage_arguments(),
-                            code_package.code_location,
-                        ],
+                        run_arguments,
                         stderr=subprocess.PIPE,
                         stdout=subprocess.PIPE,
                         check=True,
                     )
+                    
                     function_cfg.docker_image = docker_image
                     res = OpenWhiskFunction(
                         func_name, code_package.benchmark, code_package.hash, function_cfg