OS detection fixed. We can now override redis executable per os/arch

README.md

@@ -14,15 +14,26 @@ redisServer.start();
 redisServer.stop();
 ```
 
-You can also provide RedisServer with your own redis executable to run:
+You can also provide RedisServer with your own executable:
 ```java
+// 1) given explicit file (os-independence broken!)
 RedisServer redisServer = new RedisServer("/path/to/your/redis", 6379);
+
+// 2) given os-independent matrix
+RedisExecProvider customProvider = RedisExecProvider.defaultProvider()
+  .override(OS.UNIX, "/path/to/unix/redis")
+  .override(OS.WINDOWS, Architecture.x86, "/path/to/windows/redis")
+  .override(OS.Windows, Architecture.x86_64, "/path/to/windows/redis")
+  .override(OS.MAC_OS_X, Architecture.x86, "/path/to/macosx/redis")
+  .override(OS.MAC_OS_X, Architecture.x86_64, "/path/to/macosx/redis")
+
+RedisServer redisServer = new RedisServer(customProvider, 6379);
 ```
 
 You can also use fluent API to create RedisServer:
 ```java
 RedisServer redisServer = RedisServer.builder()
-  .executable("/path/to/your/redis")
+  .redisExecProvider(customRedisProvider)
   .port(6379)
   .slaveOf("locahost", 6378)
   .configFile("/path/to/your/redis.conf")
@@ -32,7 +43,7 @@ RedisServer redisServer = RedisServer.builder()
 Or even create simple redis.conf file from scratch:
 ```java
 RedisServer redisServer = RedisServer.builder()
-  .executable("/path/to/your/redis")
+  .redisExecProvider(customRedisProvider)
   .port(6379)
   .slaveOf("locahost", 6378)
   .setting("daemonize no")
@@ -135,9 +146,9 @@ Contributors
 Changelog
 ==============
 
-### 0.5
- * OS detection fix (not ready)
- * redis binary per OS/arch pair (not ready)
+### 0.5 
+ * OS detection fix
+ * redis binary per OS/arch pair
 
 ### 0.4 
  * Updated for Java 8

src/main/java/redis/embedded/RedisExecProvider.java

@@ -0,0 +1,63 @@
+package redis.embedded;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import redis.embedded.util.Architecture;
+import redis.embedded.util.JarUtil;
+import redis.embedded.util.OS;
+import redis.embedded.util.OsArchitecture;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+
+public class RedisExecProvider {
+
+    private final Map<OsArchitecture, String> executables = Maps.newHashMap();
+
+    public static RedisExecProvider defaultProvider() {
+        return new RedisExecProvider();
+    }
+
+    private RedisExecProvider() {
+        initExecutables();
+    }
+
+    private void initExecutables() {
+        executables.put(OsArchitecture.WINDOWS_x86, "redis-server.exe");
+        executables.put(OsArchitecture.WINDOWS_x86_64, "redis-server-64.exe");
+
+        executables.put(OsArchitecture.UNIX_x86, "redis-server");
+        executables.put(OsArchitecture.UNIX_x86_64, "redis-server");
+
+        executables.put(OsArchitecture.MAC_OS_X_x86, "redis-server.app");
+        executables.put(OsArchitecture.MAC_OS_X_x86_64, "redis-server.app");
+    }
+
+    public RedisExecProvider override(OS os, String executable) {
+        Preconditions.checkNotNull(executable);
+        for (Architecture arch : Architecture.values()) {
+            override(os, arch, executable);
+        }
+        return this;
+    }
+
+    public RedisExecProvider override(OS os, Architecture arch, String executable) {
+        Preconditions.checkNotNull(executable);
+        executables.put(new OsArchitecture(os, arch), executable);
+        return this;
+    }
+
+    public File get() throws IOException {
+        OsArchitecture osArch = OsArchitecture.detect();
+        String executablePath = executables.get(osArch);
+         return fileExists(executablePath) ?
+                new File(executablePath) :
+                JarUtil.extractExecutableFromJar(executablePath);
+
+    }
+
+    private boolean fileExists(String executablePath) {
+        return new File(executablePath).exists();
+    }
+}

src/main/java/redis/embedded/RedisSentinelBuilder.java

@@ -3,7 +3,6 @@
 import com.google.common.base.Preconditions;
 import com.google.common.io.Files;
 import redis.embedded.exceptions.RedisBuildingException;
-import redis.embedded.util.JarUtil;
 
 import java.io.File;
 import java.io.IOException;
@@ -21,6 +20,7 @@ public class RedisSentinelBuilder {
     private static final String PORT_LINE = "port %d";
 
     private File executable;
+    private RedisExecProvider redisExecProvider = RedisExecProvider.defaultProvider();
     private Integer port = 26379;
     private int masterPort = 6379;
     private String masterName = "mymaster";
@@ -32,13 +32,8 @@ public class RedisSentinelBuilder {
 
     private StringBuilder redisConfigBuilder;
 
-    public RedisSentinelBuilder executable(File executable) {
-        this.executable = executable;
-        return this;
-    }
-
-    public RedisSentinelBuilder executable(String executable) {
-        this.executable = new File(executable);
+    public RedisSentinelBuilder redisExecProvider(RedisExecProvider redisExecProvider) {
+        this.redisExecProvider = redisExecProvider;
         return this;
     }
 
@@ -110,10 +105,8 @@ private void tryResolveConfAndExec() {
             if (sentinelConf == null) {
                 resolveSentinelConf();
             }
-            if (executable == null) {
-                executable = JarUtil.extractExecutableFromJar(RedisRunScriptEnum.getRedisRunScript());
-            }
-        } catch (IOException e) {
+            executable = redisExecProvider.get();
+        } catch (Exception e) {
             throw new RedisBuildingException("Could not build sentinel instance", e);
         }
     }

src/main/java/redis/embedded/RedisServer.java

@@ -1,7 +1,5 @@
 package redis.embedded;
 
-import redis.embedded.util.JarUtil;
-
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -18,7 +16,7 @@ public RedisServer() throws IOException {
 
     public RedisServer(Integer port) throws IOException {
         super(port);
-        File executable = JarUtil.extractExecutableFromJar(RedisRunScriptEnum.getRedisRunScript());
+        File executable = RedisExecProvider.defaultProvider().get();
         this.args = Arrays.asList(
                 executable.getAbsolutePath(),
                 "--port", Integer.toString(port)
@@ -33,6 +31,14 @@ public RedisServer(File executable, Integer port) {
         );
     }
 
+    public RedisServer(RedisExecProvider redisExecProvider, Integer port) throws IOException {
+        super(port);
+        this.args = Arrays.asList(
+                redisExecProvider.get().getAbsolutePath(),
+                "--port", Integer.toString(port)
+        );
+    }
+
     RedisServer(List<String> args, int port) {
         super(port);
         this.args = new ArrayList<>(args);

src/main/java/redis/embedded/RedisServerBuilder.java

@@ -3,7 +3,6 @@
 import com.google.common.base.Strings;
 import com.google.common.io.Files;
 import redis.embedded.exceptions.RedisBuildingException;
-import redis.embedded.util.JarUtil;
 
 import java.io.File;
 import java.io.IOException;
@@ -17,22 +16,18 @@ public class RedisServerBuilder {
     private static final String CONF_FILENAME = "embedded-redis-server";
 
     private File executable;
+    private RedisExecProvider redisExecProvider = RedisExecProvider.defaultProvider();
     private Integer port = 6379;
     private InetSocketAddress slaveOf;
     private String redisConf;
 
     private StringBuilder redisConfigBuilder;
 
-    public RedisServerBuilder executable(File executable) {
-        this.executable = executable;
+    public RedisServerBuilder redisExecProvider(RedisExecProvider redisExecProvider) {
+        this.redisExecProvider = redisExecProvider;
         return this;
     }
-
-    public RedisServerBuilder executable(String executable) {
-        this.executable = new File(executable);
-        return this;
-    }
-
+
     public RedisServerBuilder port(Integer port) {
         this.port = port;
         return this;
@@ -77,6 +72,7 @@ public RedisServer build() {
     }
 
     public void reset() {
+        this.executable = null;
         this.redisConfigBuilder = null;
         this.slaveOf = null;
         this.redisConf = null;
@@ -98,8 +94,10 @@ private void resolveConfAndExec() throws IOException {
             redisConf = redisConfigFile.getAbsolutePath();
         }
 
-        if (executable == null) {
-            executable = JarUtil.extractExecutableFromJar(RedisRunScriptEnum.getRedisRunScript());
+        try {
+            executable = redisExecProvider.get();
+        } catch (Exception e) {
+            throw new RedisBuildingException("Failed to resolve executable", e);
         }
     }
 

src/main/java/redis/embedded/exceptions/OsDetectionException.java

@@ -0,0 +1,11 @@
+package redis.embedded.exceptions;
+
+public class OsDetectionException extends RuntimeException {
+    public OsDetectionException(String message) {
+        super(message);
+    }
+
+    public OsDetectionException(Throwable cause) {
+        super(cause);
+    }
+}

src/main/java/redis/embedded/util/Architecture.java

@@ -0,0 +1,6 @@
+package redis.embedded.util;
+
+public enum Architecture {
+    x86,
+    x86_64
+}

src/main/java/redis/embedded/util/OS.java

@@ -0,0 +1,7 @@
+package redis.embedded.util;
+
+public enum OS {
+    WINDOWS,
+    UNIX,
+    MAC_OS_X
+}

src/main/java/redis/embedded/util/OSDetector.java

@@ -1,21 +1,12 @@
 package redis.embedded.util;
 
+import redis.embedded.exceptions.OsDetectionException;
+
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 
 public class OSDetector {
 
-    public static enum OS {
-        WINDOWS,
-        UNIX,
-        MACOSX
-    }
-
-    public static enum Architecture {
-        x86,
-        x86_64
-    }
-
     public static OS getOS() {
         String osName = System.getProperty("os.name").toLowerCase();
 
@@ -24,23 +15,23 @@ public static OS getOS() {
         } else if (osName.contains("nix") || osName.contains("nux") || osName.contains("aix")) {
             return OS.UNIX;
         } else if ("Mac OS X".equalsIgnoreCase(osName)) {
-            return OS.MACOSX;
+            return OS.MAC_OS_X;
         } else {
-            throw new RuntimeException("Unrecognized OS: " + osName);
+            throw new OsDetectionException("Unrecognized OS: " + osName);
         }
     }
 
     public static Architecture getArchitecture() {
-        OS os;
-        switch (os = getOS()) {
+        OS os = getOS();
+        switch (os) {
             case WINDOWS:
                 return getWindowsArchitecture();
             case UNIX:
                 return getUnixArchitecture();
-            case MACOSX:
+            case MAC_OS_X:
                 return getMacOSXArchitecture();
             default:
-                throw new RuntimeException("Unsupported OS: " + os);
+                throw new OsDetectionException("Unrecognized OS: " + os);
         }
     }
 
@@ -69,7 +60,7 @@ private static Architecture getUnixArchitecture() {
                 }
             }
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new OsDetectionException(e);
         } finally {
             try {
                 if (input != null) {
@@ -97,7 +88,7 @@ private static Architecture getMacOSXArchitecture() {
                 }
             }
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new OsDetectionException(e);
         } finally {
             try {
                 if (input != null) {