feat: generate java componate

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>

1 files changed, 277 insertions, 0 deletions

diff --git a/generateJava.py b/generateJava.py
new file mode 100644
index 0000000000..11a449ae9f
--- /dev/null
+++ b/generateJava.py
@@ -0,0 +1,277 @@
+import copy
+import hashlib
+import os
+from collections import defaultdict, namedtuple
+from operator import attrgetter
+from pprint import pprint
+from packaging import version as pversion
+from typing import Optional, List
+
+from meta.common import ensure_component_dir, launcher_path, upstream_path, static_path
+
+from meta.common.java import (
+    JAVA_COMPONENT,
+    ADOPTIUM_DIR,
+    ADOPTIUM_VERSIONS_DIR,
+    AZUL_DIR,
+    AZUL_VERSIONS_DIR
+)
+from meta.model.java import (
+    JavaRuntimeOS,
+    JavaRuntimeMap,
+    JavaRuntimeMeta,
+    JavaVersionMeta,
+    JavaChecksumMeta,
+    JavaChecksumType,
+    JavaRuntimeDownloadType,
+    AdoptiumAvailableReleases,
+    AdoptiumReleases,
+    AdoptiumRelease,
+    AdoptiumBinary,
+    ZuluPackages,
+    ZuluPackageDetail,
+    AzulArch,
+)
+
+from meta.common.mojang import (
+
+    JAVA_MANIFEST_FILE,
+)
+
+from meta.model.mojang import (
+    JavaIndex,
+    MojangJavaComponent,
+    MojangJavaOsName,
+    MojangJavaRuntime,
+)
+
+LAUNCHER_DIR = launcher_path()
+UPSTREAM_DIR = upstream_path()
+STATIC_DIR = static_path()
+
+ensure_component_dir(JAVA_COMPONENT)
+
+MOJANG_JAVA_OS_NAMES = [
+    "gamecore",
+    "linux",
+    "linux-i386",
+    "mac-os",
+    "mac-os-arm64",
+    "windows-arm64",
+    "windows-x64",
+    "windows-x86",
+]
+
+MOJANG_OS_ARCHITECTURES = [
+    "x64",
+    "x86",  
+    "arm64",
+    "arm32",
+]
+
+MOJANG_OS_ARCHITECTURE_TRANSLATIONS = {
+    64: "x64",
+    32: "x86",
+    "x32": "x86",
+    "i386": "x86",
+    "aarch64": "arm64",
+    "x86_64": "x64",
+    "arm": "arm32"
+}
+
+
+def translate_arch(arch: str | int):
+    if isinstance(arch, str):
+        arch = arch.lower()
+    if arch in MOJANG_OS_ARCHITECTURES:
+        return arch
+    elif arch in MOJANG_OS_ARCHITECTURE_TRANSLATIONS:
+        return MOJANG_OS_ARCHITECTURE_TRANSLATIONS[arch]
+    else:
+        return None
+
+MOJANG_OS_NAMES = [
+    "mac-os",
+    "linux",
+    "windows",
+]
+
+MOJANG_OS_TRANSLATIONS = {
+    "osx": "mac-os",
+    "mac": "mac-os",
+    "macos": "mac-os",
+}
+
+def translate_os(os: str):
+    os = os.lower()
+    if os in MOJANG_OS_NAMES:
+        return os
+    elif os in MOJANG_OS_TRANSLATIONS:
+        return MOJANG_OS_TRANSLATIONS[os]
+    else:
+        return None
+
+
+def mojang_os_to_java_os(mojang_os: MojangJavaOsName) -> JavaRuntimeOS:
+    if mojang_os == MojangJavaOsName.Linux:
+        return JavaRuntimeOS.LinuxX64
+    elif mojang_os == MojangJavaOsName.Linuxi386:
+        return JavaRuntimeOS.LinuxX86
+    elif mojang_os == MojangJavaOsName.MacOs:
+        return JavaRuntimeOS.MacOsX64
+    elif mojang_os == MojangJavaOsName.MacOSArm64:
+        return JavaRuntimeOS.MacOsArm64
+    elif mojang_os == MojangJavaOsName.WindowsArm64:
+        return JavaRuntimeOS.WindowsArm64
+    elif mojang_os == MojangJavaOsName.WindowsX64:
+        return JavaRuntimeOS.WindowsX64
+    elif mojang_os == MojangJavaOsName.WindowsX86:
+        return JavaRuntimeOS.WindowsX86
+    else:
+        return JavaRuntimeOS.Unknown
+
+
+def mojang_runtime_to_java_runtime(mojang_runtime: MojangJavaRuntime) -> JavaRuntimeMeta:
+    return JavaRuntimeMeta(
+        name=f"mojang_jre_{mojang_runtime.version.name}",
+        vender="mojang",
+        url=mojang_runtime.manifest.url,
+        release_time=mojang_runtime.version.released,
+        checksum=JavaChecksumMeta(
+            type=JavaChecksumType.Sha1,
+            hash=mojang_runtime.manifest.sha1),
+        recomended=True,
+        download_type=JavaRuntimeDownloadType.Manifest)
+
+def adoptium_release_binary_to_java_runtime(rls: AdoptiumRelease, binary: AdoptiumBinary) -> JavaRuntimeMeta:
+    version = JavaVersionMeta(
+        major=rls.version_data.major,
+        minor=rls.version_data.minor,
+        security=rls.version_data.security,
+        build=rls.version_data.build
+    )
+    rls_name = f"{rls.vendor}_temurin_{binary.image_type}{version}"
+    return JavaRuntimeMeta(
+        name=rls_name,
+        vender=rls.vendor,
+        url=binary.package.link,
+        release_time=rls.timestamp,
+        checksum=JavaChecksumMeta(
+            type=JavaChecksumType.Sha256,
+            hash=binary.package.checksum),
+        recomended=False,
+        download_type=JavaRuntimeDownloadType.Archive
+    )
+
+def azul_package_to_java_runtime(pkg: ZuluPackageDetail) -> JavaRuntimeMeta:
+    version_parts = copy.copy(pkg.java_version)
+    while len(version_parts) < 4:
+        version_parts.append(None)
+    
+    version = JavaVersionMeta(
+        major=version_parts[0],
+        minor=version_parts[1],
+        security=version_parts[2],
+        build=version_parts[3]
+    )
+    
+    rls_name = f"azul_{pkg.product}_{pkg.java_package_type}{version}"
+    
+    return JavaRuntimeMeta(
+        name=rls_name,
+        vender="azul",
+        url=pkg.download_url,
+        release_time=pkg.build_date,
+        checksum=JavaChecksumMeta(
+            type=JavaChecksumType.Sha256,
+            hash=pkg.sha256_hash),
+        recomended=False,
+        download_type=JavaRuntimeDownloadType.Archive
+    )
+
+def main():
+    
+    javas: dict[int, JavaRuntimeMap] = {}
+    
+    def ensure_javamap(major: int):
+        if major not in javas:
+            javas[major] = JavaRuntimeMap()
+            
+    def add_java_runtime(runtime: JavaRuntimeMeta, major: int, java_os: JavaRuntimeOS):
+        ensure_javamap(major)
+        print(f"Regestering runtime: {runtime.name} for Java {major} {java_os}")
+        javas[major][java_os].append(runtime)
+    
+    print("Processing Mojang Javas")
+    mojang_java_manifest = JavaIndex.parse_file(
+        os.path.join(UPSTREAM_DIR, JAVA_MANIFEST_FILE)
+    )
+    for mojang_os_name in mojang_java_manifest:
+        if mojang_os_name == MojangJavaOsName.Gamecore:
+            continue
+        java_os = mojang_os_to_java_os(mojang_os_name)
+        for comp in mojang_java_manifest[mojang_os_name]:
+            mojang_runtimes = mojang_java_manifest[mojang_os_name][comp]
+            for mojang_runtime in mojang_runtimes:
+                if comp == MojangJavaComponent.JreLegacy:
+                    major = 8
+                else:
+                    major = int(mojang_runtime.version.name.partition('.')[0])
+                runtime = mojang_runtime_to_java_runtime(mojang_runtime)
+                add_java_runtime(runtime, major, java_os)
+                
+    print("Processing Adoptium Releases")
+    adoptium_available_releases = AdoptiumAvailableReleases.parse_file(
+        os.path.join(UPSTREAM_DIR, ADOPTIUM_DIR, "available_releases.json")
+    )
+    for major in adoptium_available_releases.available_releases:
+        adoptium_releases = AdoptiumReleases.parse_file(
+            os.path.join(UPSTREAM_DIR, ADOPTIUM_VERSIONS_DIR, f"java{major}.json")
+        )
+        for rls in adoptium_releases:
+            for binary in rls.binaries:
+                if binary.package is None:
+                    continue
+                binary_arch = translate_arch(str(binary.architecture))
+                binary_os = translate_os(str(binary.os))
+                if binary_arch is None or binary_os is None:
+                    print(f"Ignoring release for {binary.os} {binary.architecture}")
+                    continue
+                    
+                java_os = JavaRuntimeOS(f"{binary_os}-{binary_arch}")
+                runtime = adoptium_release_binary_to_java_runtime(rls, binary)
+                add_java_runtime(runtime, major, java_os)
+    
+    print("Processing Azul Packages")
+    azul_packages = ZuluPackages.parse_file(
+        os.path.join(UPSTREAM_DIR, AZUL_DIR, "packages.json")
+    )
+    for pkg in azul_packages:
+        pkg_detail = ZuluPackageDetail.parse_file(
+            os.path.join(UPSTREAM_DIR, AZUL_VERSIONS_DIR, f"{pkg.package_uuid}.json")
+        )
+        major =  pkg_detail.java_version[0]
+        pkg_os = translate_os(str(pkg_detail.os))
+        if pkg_detail.arch == AzulArch.Arm:   
+            pkg_arch = translate_arch(f"{pkg_detail.arch}{pkg_detail.hw_bitness}")
+        elif  pkg_detail.arch == AzulArch.X86:
+            pkg_arch = translate_arch(int(pkg_detail.hw_bitness))
+        else:
+            pkg_arch = None
+        if pkg_arch is None or pkg_os is None:
+            print(f"Ignoring release for {pkg_detail.os} {pkg_detail.arch}_{pkg_detail.hw_bitness}")
+            continue
+        
+        java_os = JavaRuntimeOS(f"{pkg_os}-{pkg_arch}")
+        runtime = azul_package_to_java_runtime(pkg_detail)
+        add_java_runtime(runtime, major, java_os)
+    
+    for major, runtimes in javas.items():
+        for java_os in runtimes:
+            print(f"Total runtimes for Java {major} {java_os}:", len(runtimes[java_os]))
+        runtimes_file = os.path.join(LAUNCHER_DIR, JAVA_COMPONENT, f"java{major}.json")
+        runtimes.write(runtimes_file)
+        
+
+if __name__ == "__main__":
+    main()