🐛 Do not attempt to re-create Redis executable multiples times in RedisHighAvailabilityContextCustomizer

Author: tobi-laa

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/cluster/RedisClusterContextCustomizer.kt

@@ -14,7 +14,7 @@ import redis.clients.jedis.JedisCluster
 import redis.embedded.RedisServer
 import redis.embedded.RedisServer.newRedisServer
 import redis.embedded.RedisShardedCluster
-import redis.embedded.core.ExecutableProvider
+import redis.embedded.core.ExecutableProvider.newJarResourceProvider
 import redis.embedded.core.RedisServerBuilder
 import java.io.File
 import java.time.Duration
@@ -25,8 +25,8 @@ import kotlin.streams.toList
 private const val CLUSTER_IP = "127.0.0.1"
 
 internal class RedisClusterContextCustomizer(
-    private val config: EmbeddedRedisCluster,
-    private val portProvider: PortProvider = PortProvider()
+        private val config: EmbeddedRedisCluster,
+        private val portProvider: PortProvider = PortProvider()
 ) : ContextCustomizer {
 
     private val log = LoggerFactory.getLogger(javaClass)
@@ -56,9 +56,9 @@ internal class RedisClusterContextCustomizer(
         val shards = config.shards.map { createShard(it, ports) }
         val nodes = shards.map { it.second + it.first }.flatten().toList()
         val replicasPortsByMainNodePort =
-            shards.associate { s -> s.first.ports().first() to s.second.map { it.ports() }.flatten().toSet() }
+                shards.associate { s -> s.first.ports().first() to s.second.map { it.ports() }.flatten().toSet() }
         val cluster =
-            RedisShardedCluster(nodes, replicasPortsByMainNodePort, Duration.ofSeconds(config.initializationTimeout))
+                RedisShardedCluster(nodes, replicasPortsByMainNodePort, Duration.ofSeconds(config.initializationTimeout))
         return cluster
     }
 
@@ -80,8 +80,8 @@ internal class RedisClusterContextCustomizer(
     }
 
     private fun createShard(
-        shard: EmbeddedRedisCluster.Shard,
-        ports: Iterator<Int>
+            shard: EmbeddedRedisCluster.Shard,
+            ports: Iterator<Int>
     ): Pair<RedisServer, List<RedisServer>> {
         val name = shard.name.ifEmpty { BirdNameProvider.next() }
 
@@ -96,22 +96,22 @@ internal class RedisClusterContextCustomizer(
 
     private fun createNodeBuilder(port: Int): RedisServerBuilder {
         val builder = newRedisServer()
-            .bind(CLUSTER_IP)
-            .port(port)
-            .setting("cluster-enabled yes")
-            .setting("cluster-config-file nodes-replica-$port.conf")
-            .setting("cluster-node-timeout 5000")
-            .setting("appendonly no")
+                .bind(CLUSTER_IP)
+                .port(port)
+                .setting("cluster-enabled yes")
+                .setting("cluster-config-file nodes-replica-$port.conf")
+                .setting("cluster-node-timeout 5000")
+                .setting("appendonly no")
         if (config.executeInDirectory.isNotEmpty()) {
-            builder.executableProvider(ExecutableProvider.newJarResourceProvider(File(config.executeInDirectory)))
+            builder.executableProvider(newJarResourceProvider(File(config.executeInDirectory)))
         }
         return builder
     }
 
     private fun parseAddresses(cluster: RedisShardedCluster): List<Pair<String, Int>> =
-        cluster.servers()
-            .map { CLUSTER_IP to it.ports().first() }
-            .toList()
+            cluster.servers()
+                    .map { CLUSTER_IP to it.ports().first() }
+                    .toList()
 
     private fun createClient(addresses: List<Pair<String, Int>>): RedisClient {
         val jedisCluster = JedisCluster(addresses.map { HostAndPort(it.first, it.second) }.toSet())
@@ -120,16 +120,16 @@ internal class RedisClusterContextCustomizer(
 
     private fun setSpringProperties(context: ConfigurableApplicationContext, addresses: List<Pair<String, Int>>) {
         TestPropertyValues.of(
-            mapOf(
-                "spring.data.redis.cluster.nodes" to addresses.joinToString(",") { createAddress(it.first, it.second) }
-            )
+                mapOf(
+                        "spring.data.redis.cluster.nodes" to addresses.joinToString(",") { createAddress(it.first, it.second) }
+                )
         ).applyTo(context.environment)
     }
 
     private fun addShutdownListener(
-        context: ConfigurableApplicationContext,
-        cluster: RedisShardedCluster,
-        client: RedisClient
+            context: ConfigurableApplicationContext,
+            cluster: RedisShardedCluster,
+            client: RedisClient
     ) {
         context.addApplicationListener { event ->
             if (event is ContextClosedEvent) {

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/highavailability/RedisHighAvailabilityContextCustomizer.kt

@@ -20,7 +20,7 @@ import redis.embedded.core.ExecutableProvider
 import redis.embedded.core.ExecutableProvider.newJarResourceProvider
 import redis.embedded.core.ExecutableProvider.newProvidedVersionsMap
 import redis.embedded.core.RedisServerBuilder
-import redis.embedded.model.OsArchitecture
+import redis.embedded.model.OsArchitecture.detectOSandArchitecture
 import redis.embedded.util.IO.writeResourceToExecutableFile
 import java.nio.file.Files.exists
 import java.util.stream.IntStream
@@ -44,13 +44,14 @@ internal class RedisHighAvailabilityContextCustomizer(
     private var nodeProvider: NodeProvider? = null
     private val customizer = config.customizer.map { c -> c.createInstance() }.toList()
     private val executableProvider = if (config.executeInDirectory.isNotEmpty()) {
-        val osArch = OsArchitecture.detectOSandArchitecture()
-        val executable = Path(config.executeInDirectory, newProvidedVersionsMap()[osArch]!!)
+        val osArch = detectOSandArchitecture()
+        val resourcePath = newProvidedVersionsMap()[osArch]!!
+        val executable = Path(config.executeInDirectory, resourcePath)
         ExecutableProvider {
             if (exists(executable)) {
                 executable.toFile()
             } else {
-                writeResourceToExecutableFile(executable.parent.toFile(), executable.fileName.toString())
+                writeResourceToExecutableFile(executable.parent.toFile(), resourcePath)
             }
         }
     } else {