add dynamic corretto version check

Author: e-kotov

NAMESPACE

@@ -10,6 +10,7 @@ export(java_install)
 export(java_list)
 export(java_quick_install)
 export(java_unpack)
+export(java_valid_versions)
 export(rje_consent)
 export(use_java)
 importFrom(utils,getFromNamespace)

R/internal_utilities.R

@@ -7,20 +7,22 @@
 platform_detect <- function(quiet = TRUE) {
   sys_info <- tolower(Sys.info())
 
-  os <- switch(sys_info["sysname"],
+  os <- switch(
+    sys_info["sysname"],
     "windows" = "windows",
     "linux" = "linux",
     "darwin" = "macos",
     stop(cli::cli_abort("Unsupported platform"))
   )
 
-  arch <- switch(sys_info["machine"],
+  arch <- switch(
+    sys_info["machine"],
     "x86-64" = "x64",
     "x86_64" = "x64",
     "i386" = "x86",
     "i686" = "x86",
-    "aarch64" = "arm64",
-    "arm64" = "arm64",
+    "aarch64" = "aarch64",
+    "arm64" = "aarch64",
     stop(cli::cli_abort("Unsupported architecture"))
   )
 
@@ -67,7 +69,10 @@ urls_test_all <- function() {
 
         try(
           {
-            response <- curl::curl_fetch_memory(url, handle = curl::new_handle(nobody = TRUE))
+            response <- curl::curl_fetch_memory(
+              url,
+              handle = curl::new_handle(nobody = TRUE)
+            )
             status <- response$status_code
           },
           silent = TRUE
@@ -113,9 +118,18 @@ java_version_check_rscript <- function(java_home) {
       Sys.setenv(PATH = paste(new_path, old_path, sep = .Platform$path.sep))
 
       suppressWarnings(rJava::.jinit())
-      suppressWarnings(java_version <- rJava::.jcall("java.lang.System", "S", "getProperty", "java.version"))
+      suppressWarnings(
+        java_version <- rJava::.jcall(
+          "java.lang.System",
+          "S",
+          "getProperty",
+          "java.version"
+        )
+      )
 
-      message <- cli::format_message("rJava and other rJava/Java-based packages will use Java version: {.val {java_version}}")
+      message <- cli::format_message(
+        "rJava and other rJava/Java-based packages will use Java version: {.val {java_version}}"
+      )
 
       message
     },

R/java_download.R

@@ -1,6 +1,6 @@
 #' Download a Java distribution
 #'
-#' @param version `Integer` or `character` vector of length 1 for major version of Java to download or install. If not specified, defaults to the latest LTS version. Can be "8", "11", "17", "21", "22", or 8, 11, 17, 21, or 22.
+#' @param version `Integer` or `character` vector of length 1 for major version of Java to download or install. If not specified, defaults to the latest LTS version. Can be "8", "11", "17", "21", "22", "23", "24", or 8, 11, 17, 21, 22, 23, 24 or any newer version if it is available for the selected distribution.
 #' @param distribution The Java distribution to download. If not specified, defaults to "Amazon Corretto". Currently only \href{https://aws.amazon.com/corretto/}{"Amazon Corretto"} is supported.
 #' @param cache_path The destination directory to download the Java distribution to. Defaults to a user-specific data directory.
 #' @param platform The platform for which to download the Java distribution. Defaults to the current platform.
@@ -31,10 +31,8 @@ java_download <- function(
   force = FALSE,
   temp_dir = FALSE
 ) {
-
   # Download distribution and check MD5 checksum
   download_dist_check_md5 <- function(url, dest_file, quiet) {
-
     curl::curl_download(url, dest_file, quiet = FALSE)
     curl::curl_download(url_md5, dest_file_md5, quiet = TRUE)
 
@@ -45,7 +43,10 @@ java_download <- function(
     md5sum_expected <- readLines(dest_file_md5, warn = FALSE)
 
     if (md5sum != md5sum_expected) {
-      cli::cli_abort("MD5 checksum mismatch. Please try downloading the file again.", .envir = environment())
+      cli::cli_abort(
+        "MD5 checksum mismatch. Please try downloading the file again.",
+        .envir = environment()
+      )
       unlink(dest_file)
       return(NULL)
     } else {
@@ -75,7 +76,10 @@ java_download <- function(
   # Checks for the parameters
   checkmate::check_vector(version, len = 1)
   version <- as.character(version)
-  checkmate::assert_choice(version, getOption("rJavaEnv.valid_major_java_versions"))
+  checkmate::assert_choice(
+    as.character(version),
+    java_valid_versions()
+  )
 
   checkmate::assert_choice(distribution, valid_distributions)
 
@@ -101,15 +105,24 @@ java_download <- function(
   }
 
   if (!distribution %in% names(java_urls)) {
-    cli::cli_abort("Unsupported distribution: {.val {distribution}}", .envir = environment())
+    cli::cli_abort(
+      "Unsupported distribution: {.val {distribution}}",
+      .envir = environment()
+    )
   }
 
   if (!platform %in% names(java_urls[[distribution]])) {
-    cli::cli_abort("Unsupported platform: {.val {platform}}", .envir = environment())
+    cli::cli_abort(
+      "Unsupported platform: {.val {platform}}",
+      .envir = environment()
+    )
   }
 
   if (!arch %in% names(java_urls[[distribution]][[platform]])) {
-    cli::cli_abort("Unsupported architecture: {.val {arch}}", .envir = environment())
+    cli::cli_abort(
+      "Unsupported architecture: {.val {arch}}",
+      .envir = environment()
+    )
   }
 
   url_template <- java_urls[[distribution]][[platform]][[arch]]
@@ -120,17 +133,23 @@ java_download <- function(
   dest_file_md5 <- paste0(file.path(cache_path, basename(url_md5)), ".md5")
 
   if (!quiet) {
-    cli::cli_inform("Downloading Java {version} ({distribution}) for {platform} {arch} to {dest_file}", .envir = environment())
+    cli::cli_inform(
+      "Downloading Java {version} ({distribution}) for {platform} {arch} to {dest_file}",
+      .envir = environment()
+    )
   }
 
   if (file.exists(dest_file) & !force) {
     if (!quiet) {
-      cli::cli_inform("File already exists. Skipping download.", .envir = environment())
+      cli::cli_inform(
+        "File already exists. Skipping download.",
+        .envir = environment()
+      )
     }
-  } else if(file.exists(dest_file) & force) {
+  } else if (file.exists(dest_file) & force) {
     if (!quiet) {
       cli::cli_inform("Removing existing installation.", .envir = environment())
-      }
+    }
     file.remove(dest_file)
     download_dist_check_md5(url, dest_file, quiet)
   } else if (!file.exists(dest_file)) {

R/java_valid_versions.R

@@ -0,0 +1,137 @@
+#' Retrieve Valid Java Versions
+#'
+#' This function retrieves a list of valid Java versions by querying an appropriate API endpoint based on the chosen distribution.
+#' The result is cached for 8 hours to avoid repeated API calls. If the API call fails (for example, due to a lack of internet connectivity),
+#' the function falls back to a pre-defined list of Java versions.
+#'
+#' @param distribution Character. The Java distribution to use. If set to `"Oracle"`, the Oracle API is used.
+#'   If set to `"Corretto"` (the default), an Amazon Corretto endpoint is used.
+#' @param force Logical. If TRUE, forces a fresh API call even if a cached value exists. Defaults to FALSE.
+#'
+#' @return A character vector of valid Java versions.
+#'
+#' @examples
+#' \dontrun{
+#'   # Retrieve valid Java versions (cached if available) using Amazon Corretto endpoint
+#'   versions <- java_valid_versions()
+#'
+#'   # Force refresh the list of Java versions using the Oracle endpoint
+#'   versions <- java_valid_versions(distribution = "Corretto", force = TRUE)
+#' }
+#'
+#' @export
+java_valid_versions <- function(
+  distribution = "Corretto",
+  force = FALSE
+) {
+  # Define cache expiry time (in hours)
+  expiry_hours <- 8
+
+  # Retrieve cached values from options
+  valid_versions_cache <- getOption("rJavaEnv.valid_versions_cache")
+  valid_versions_timestamp <- getOption("rJavaEnv.valid_versions_timestamp")
+
+  # Return cached value if available and not expired, unless force is TRUE.
+  if (
+    !force &&
+      !is.null(valid_versions_cache) &&
+      !is.null(valid_versions_timestamp) &&
+      as.numeric(difftime(
+        Sys.time(),
+        valid_versions_timestamp,
+        units = "hours"
+      )) <
+        expiry_hours
+  ) {
+    return(valid_versions_cache)
+  }
+
+  # Select helper based on distribution value.
+  new_versions <- switch(
+    distribution,
+    # "Oracle" = java_valid_versions_oracle(),
+    "Corretto" = java_valid_major_versions_corretto(),
+    stop("Unsupported distribution")
+  )
+
+  # Update the cache options with the new values and current timestamp.
+  options(
+    rJavaEnv.valid_versions_cache = new_versions,
+    rJavaEnv.valid_versions_timestamp = Sys.time()
+  )
+
+  return(new_versions)
+}
+
+#' Get Available Online Versions of Amazon Corretto
+#'
+#' This function downloads the latest Amazon Corretto version information from the
+#' Corretto GitHub endpoint and returns a data frame with details for all eligible releases.
+#'
+#' It leverages the existing \code{platform_detect()} function to infer the current operating
+#' system and architecture if these are not provided.
+#'
+#' @param arch Optional character string for the target architecture (e.g., "x64").
+#'   If \code{NULL}, it is inferred using \code{platform_detect()}.
+#' @param platform Optional character string for the operating system (e.g., "windows", "macos", "linux").
+#'   If \code{NULL}, it is inferred using \code{platform_detect()}.
+#' @param imageType Optional character string to filter on; defaults to \code{"jdk"}.
+#' @param extension Optional character string specifying the desired file extension; defaults to \code{"tar.gz"}.
+#'
+#' @return A `character` vector of available major Corretto versions.
+#'
+java_valid_major_versions_corretto <- function(
+  arch = NULL,
+  platform = NULL,
+  imageType = "jdk",
+  extension = "tar.gz"
+) {
+  # If platform or arch are not provided, detect them using the existing function.
+  if (is.null(platform) || is.null(arch)) {
+    plat <- platform_detect(quiet = TRUE)
+    if (is.null(platform)) platform <- plat$os
+    if (is.null(arch)) arch <- plat$arch
+  }
+
+  # URL for the Corretto version information.
+  availableVersionsUrl <- "https://corretto.github.io/corretto-downloads/latest_links/indexmap_with_checksum.json"
+
+  # Fetch and parse the JSON using httr.
+  corretto_versions <- tryCatch(
+    {
+      json_data <- jsonlite::read_json(availableVersionsUrl)
+      eligible <- json_data[[platform]][[arch]][[imageType]]
+      if (is.null(eligible)) {
+        stop(
+          "No eligible versions found for the specified platform, architecture, and image type."
+        )
+      }
+      names(eligible)
+    },
+    error = function(e) {
+      getOption("rJavaEnv.fallback_valid_versions")
+    }
+  )
+
+  corretto_versions <- as.character(sort(as.numeric(corretto_versions)))
+  return(corretto_versions)
+}
+
+# Helper function for Oracle distribution
+# java_valid_versions_oracle <- function() {
+#   oracle_api_url <- "https://java.oraclecloud.com/javaVersions"
+#   tryCatch(
+#     {
+#       oracle_java_versions <- jsonlite::fromJSON(
+#         oracle_api_url,
+#         simplifyDataFrame = TRUE
+#       )
+#       # Combine "8" and "11" with the sorted versions from the API
+#       c("8", "11", sort(as.character(oracle_java_versions$items$jdkVersion)))
+#     },
+#     error = function(e) {
+#       # If the API call fails, use the fallback list stored in options.
+#       getOption("rJavaEnv.fallback_valid_versions")
+#     }
+#   )
+# }

R/onLoad.R

@@ -4,7 +4,23 @@
     # this default folder choice is in-line with what renv package does
     # https://github.com/rstudio/renv/blob/d6bced36afa0ad56719ca78be6773e9b4bbb078f/R/bootstrap.R#L940-L950
     rJavaEnv.cache_path = tools::R_user_dir("rJavaEnv", which = "cache"),
-    rJavaEnv.valid_major_java_versions = c("8", "11", "17", "21", "22")
+    rJavaEnv.valid_versions_cache = NULL,
+    rJavaEnv.valid_versions_timestamp = NULL,
+    # Fallback list of valid Java versions if the API call fails (e.g., no internet) as of 2025-04-02
+    rJavaEnv.fallback_valid_versions = c(
+      "8",
+      "11",
+      # "15", # not available from Amazon Corretto
+      # "16", # not available from Amazon Corretto
+      "17",
+      "18",
+      "19",
+      "20",
+      "21",
+      "22",
+      "23",
+      "24"
+    )
   )
   toset <- !(names(op.rJavaEnv) %in% names(op))
   if (any(toset)) options(op.rJavaEnv[toset])