Fix #20657: podman compatibility

Author: LEDfan

pom.xml

@@ -32,7 +32,7 @@
         <log4j.version>2.24.3</log4j.version>
         <okhttp.version>4.12.0</okhttp.version>
         <fabric8.client.version>7.1.0</fabric8.client.version>
-        <docker.client.version>7.0.8-OA-3</docker.client.version>
+        <docker.client.version>7.0.8-OA-4</docker.client.version>
         <jersey.version>3.1.10</jersey.version>
         <apache.commons.lang3>3.17.0</apache.commons.lang3>
         <!-- Plugin versions -->

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/CaddyConfig.kt

@@ -31,6 +31,7 @@ import eu.openanalytics.shinyproxyoperator.model.ShinyProxy
 import eu.openanalytics.shinyproxyoperator.model.ShinyProxyInstance
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.IO
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
@@ -56,7 +57,7 @@ class CaddyConfig(private val dockerClient: DockerClient, mainDataDir: Path, con
     private val objectMapper = ObjectMapper()
     private val yamlMapper = ObjectMapper(YAMLFactory())
     private val fileManager = FileManager()
-    private val caddyImage: String = config.readConfigValue("caddy:2.8", "SPO_CADDY_IMAGE") { it }
+    private val caddyImage: String = config.readConfigValue("docker.io/library/caddy:2.8", "SPO_CADDY_IMAGE") { it }
     private val enableTls = config.readConfigValue(false, "SPO_CADDY_ENABLE_TLS") { it.toBoolean() }
     private val client: OkHttpClient = OkHttpClient.Builder()
         .connectTimeout(3, TimeUnit.SECONDS)

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/DockerOrchestrator.kt

@@ -42,6 +42,7 @@ import eu.openanalytics.shinyproxyoperator.model.ShinyProxyStatus
 import eu.openanalytics.shinyproxyoperator.prettyMessage
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.IO
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.withContext
 import org.apache.commons.lang3.RandomStringUtils
@@ -66,6 +67,7 @@ class DockerOrchestrator(channel: Channel<ShinyProxyEvent>,
                          private val inputDir: Path) : IOrchestrator {
 
     private val dockerGID: Int = config.readConfigValue(null, "SPO_DOCKER_GID") { it.toInt() }
+    private val dockerSocket: String = config.readConfigValue("/var/run/docker.sock", "SPO_DOCKER_SOCKET") { it }
     private val disableICC: Boolean = config.readConfigValue(false, "SPO_DISABLE_ICC") { it.toBoolean() }
     private val state = mutableMapOf<String, ShinyProxyStatus>()
 
@@ -93,14 +95,15 @@ class DockerOrchestrator(channel: Channel<ShinyProxyEvent>,
         objectMapper.propertyNamingStrategy = PropertyNamingStrategies.KEBAB_CASE
         dockerClient = JerseyDockerClientBuilder()
             .fromEnv()
+            .uri("unix://" + dockerSocket)
             .readTimeoutMillis(0) // no timeout, needed for startContainer and logs, #32606
             .build()
         caddyConfig = CaddyConfig(dockerClient, dataDir, config)
         dockerActions = DockerActions(dockerClient)
         shinyProxyReadyChecker = ShinyProxyReadyChecker(channel, dockerActions, dockerClient, dataDir)
         redisConfig = RedisConfig(dockerClient, dockerActions, persistentState, dataDir, config)
         craneConfig = CraneConfig(dockerClient, dockerActions, dataDir, inputDir, redisConfig, caddyConfig, persistentState)
-        monitoringConfig = MonitoringConfig(dockerClient, dockerActions, dataDir, caddyConfig, config)
+        monitoringConfig = MonitoringConfig(dockerClient, dockerActions, dataDir, caddyConfig, config, dockerSocket)
         logFilesCleaner = LogFilesCleaner(dataDir.resolve("logs"), fileManager, dockerActions)
         fileManager.createDirectories(dataDir)
         eventWriter = FileWriter(dataDir.resolve("events.json").toFile())
@@ -223,7 +226,7 @@ class DockerOrchestrator(channel: Channel<ShinyProxyEvent>,
                     .networkMode(SHARED_NETWORK_NAME)
                     .binds(
                         HostConfig.Bind.builder()
-                            .from("/var/run/docker.sock")
+                            .from(dockerSocket)
                             .to("/var/run/docker.sock")
                             .readOnly(true)
                             .build(),

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/RedisConfig.kt

@@ -24,6 +24,7 @@ import eu.openanalytics.shinyproxyoperator.Config
 import eu.openanalytics.shinyproxyoperator.FileManager
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.IO
 import kotlinx.coroutines.withContext
 import org.apache.commons.lang3.RandomStringUtils
 import org.mandas.docker.client.DockerClient
@@ -42,7 +43,7 @@ class RedisConfig(private val dockerClient: DockerClient,
     private val dataDir: Path = mainDataDir.resolve(containerName)
     private lateinit var redisPassword: String
     private val logger = KotlinLogging.logger {}
-    private val redisImage: String = config.readConfigValue("redis:7.2.4", "SPO_REDIS_IMAGE") { it }
+    private val redisImage: String = config.readConfigValue("docker.io/library/redis:7.2.4", "SPO_REDIS_IMAGE") { it }
     private val fileManager = FileManager()
 
     fun init() {

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/monitoring/CAdvisorConfig.kt

@@ -29,7 +29,7 @@ import org.mandas.docker.client.messages.ContainerConfig
 import org.mandas.docker.client.messages.Device
 import org.mandas.docker.client.messages.HostConfig
 
-class CAdvisorConfig(private val dockerClient: DockerClient, private val dockerActions: DockerActions, config: Config) {
+class CAdvisorConfig(private val dockerClient: DockerClient, private val dockerActions: DockerActions, config: Config, private val dockerSocket: String) {
 
     private val logger = KotlinLogging.logger {}
     private val cAdvisorImage: String = config.readConfigValue("gcr.io/cadvisor/cadvisor:v0.49.1", "SPO_CADVISOR_IMAGE") { it }
@@ -49,7 +49,7 @@ class CAdvisorConfig(private val dockerClient: DockerClient, private val dockerA
             .networkMode(DockerOrchestrator.SHARED_NETWORK_NAME)
             .binds(
                 HostConfig.Bind.builder()
-                    .from("/var/run/docker.sock")
+                    .from(dockerSocket)
                     .to("/var/run/docker.sock")
                     .readOnly(true)
                     .build(),

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/monitoring/GrafanaConfig.kt

@@ -37,7 +37,7 @@ import java.nio.file.Path
 class GrafanaConfig(private val dockerClient: DockerClient, private val dockerActions: DockerActions, private val mainDataDir: Path, private val caddyConfig: CaddyConfig, config: Config) {
 
     private val logger = KotlinLogging.logger {}
-    private val grafanaImage: String = config.readConfigValue("grafana/grafana-oss:11.5.1", "SPO_GRAFANA_IMAGE") { it }
+    private val grafanaImage: String = config.readConfigValue("docker.io/grafana/grafana-oss:11.5.1", "SPO_GRAFANA_IMAGE") { it }
     private val grafanaRole: String = config.readConfigValue("Viewer", "SPO_GRAFANA_ROLE") { it }
     private val fileManager = FileManager()
 

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/monitoring/GrafanaLokiConfig.kt

@@ -34,7 +34,7 @@ import java.nio.file.Path
 class GrafanaLokiConfig(private val dockerClient: DockerClient, private val dockerActions: DockerActions, mainDataDir: Path, config: Config) {
 
     private val logger = KotlinLogging.logger {}
-    private val lokiImage: String = config.readConfigValue("grafana/loki:3.2.2", "SPO_GRAFANA_GRAFANA_IMAGE") { it }
+    private val lokiImage: String = config.readConfigValue("docker.io/grafana/loki:3.2.2", "SPO_GRAFANA_GRAFANA_IMAGE") { it }
     private val fileManager = FileManager()
     private val containerName = "sp-grafana-loki"
     private val dataDir: Path = mainDataDir.resolve(containerName)

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/monitoring/MonitoringConfig.kt

@@ -24,18 +24,29 @@ import eu.openanalytics.shinyproxyoperator.Config
 import eu.openanalytics.shinyproxyoperator.impl.docker.CaddyConfig
 import eu.openanalytics.shinyproxyoperator.impl.docker.DockerActions
 import eu.openanalytics.shinyproxyoperator.model.ShinyProxy
+import io.github.oshai.kotlinlogging.KotlinLogging
 import org.mandas.docker.client.DockerClient
 import java.nio.file.Path
 
-class MonitoringConfig(dockerClient: DockerClient, dockerActions: DockerActions, mainDataDir: Path, caddyConfig: CaddyConfig, config: Config) {
-
-    private val enableMonitoring = config.readConfigValue(false, "SPO_ENABLE_MONITORING") { it.toBoolean() }
+class MonitoringConfig(dockerClient: DockerClient, dockerActions: DockerActions, mainDataDir: Path, caddyConfig: CaddyConfig, config: Config, dockerSocket: String) {
 
+    private val logger = KotlinLogging.logger { }
+    private val enableMonitoring: Boolean
     internal val grafanaLokiConfig = GrafanaLokiConfig(dockerClient, dockerActions, mainDataDir, config)
-    private val prometheusConfig = PrometheusConfig(dockerClient, dockerActions, mainDataDir, config)
-    private val cAdvisorConfig = CAdvisorConfig(dockerClient, dockerActions, config)
+    private val prometheusConfig = PrometheusConfig(dockerClient, dockerActions, mainDataDir, config, dockerSocket)
+    private val cAdvisorConfig = CAdvisorConfig(dockerClient, dockerActions, config, dockerSocket)
     internal val grafanaConfig = GrafanaConfig(dockerClient, dockerActions, mainDataDir, caddyConfig, config)
 
+    init {
+        val enableMonitoringConfig = config.readConfigValue(false, "SPO_ENABLE_MONITORING") { it.toBoolean() }
+        if (enableMonitoringConfig && isPodman()) {
+            logger.warn { "Monitoring is not supported on podman. Continuing without monitoring." }
+            enableMonitoring = false
+        } else {
+            enableMonitoring = enableMonitoringConfig
+        }
+    }
+
     suspend fun reconcile(shinyProxy: ShinyProxy) {
         if (enableMonitoring) {
             grafanaLokiConfig.reconcile()
@@ -49,4 +60,8 @@ class MonitoringConfig(dockerClient: DockerClient, dockerActions: DockerActions,
         return enableMonitoring
     }
 
+    private fun isPodman(): Boolean {
+        return System.getenv("container") == "podman"
+    }
+
 }

src/main/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/monitoring/PrometheusConfig.kt

@@ -30,11 +30,11 @@ import org.mandas.docker.client.messages.ContainerConfig
 import org.mandas.docker.client.messages.HostConfig
 import java.nio.file.Path
 
-class PrometheusConfig(private val dockerClient: DockerClient, private val dockerActions: DockerActions, mainDataDir: Path, config: Config) {
+class PrometheusConfig(private val dockerClient: DockerClient, private val dockerActions: DockerActions, mainDataDir: Path, config: Config, private val dockerSocket: String) {
 
     private val logger = KotlinLogging.logger {}
     private val dockerGID = config.readConfigValue(null, "SPO_DOCKER_GID") { it.toInt() }
-    private val prometheusImage: String = config.readConfigValue("prom/prometheus:v3.0.1", "SPO_PROMETHEUS_IMAGE") { it }
+    private val prometheusImage: String = config.readConfigValue("docker.io/prom/prometheus:v3.0.1", "SPO_PROMETHEUS_IMAGE") { it }
     private val fileManager = FileManager()
     private val containerName = "sp-prometheus"
     private val dataDir: Path = mainDataDir.resolve(containerName)
@@ -59,7 +59,7 @@ class PrometheusConfig(private val dockerClient: DockerClient, private val docke
             .networkMode(DockerOrchestrator.SHARED_NETWORK_NAME)
             .binds(
                 HostConfig.Bind.builder()
-                    .from("/var/run/docker.sock")
+                    .from(dockerSocket)
                     .to("/var/run/docker.sock")
                     .readOnly(true)
                     .build(),

src/test/kotlin/eu/openanalytics/shinyproxyoperator/impl/docker/helpers/IntegrationTestBase.kt

@@ -70,6 +70,7 @@ abstract class IntegrationTestBase {
     protected val scope = CoroutineScope(Dispatchers.Default)
     val dockerClient: DockerClient = JerseyDockerClientBuilder()
         .fromEnv()
+        .uri("unix://" + Config().readConfigValue("/var/run/docker.sock", "SPO_DOCKER_SOCKET") { it })
         .readTimeoutMillis(0) // no timeout, needed for startContainer and logs, #32606
         .build()
     protected val dockerActions = DockerActions(dockerClient)