Fix #13 When Scala hasn't been loaded, load the latest available version, instead of the hard coded 2.11.4

Author: ngocdaothanh

README.md

@@ -6,44 +6,46 @@ JVM processes without any prior setup at the target process.
 ## Download
 
 Download and extract
-[scalive-1.5.zip](https://github.com/xitrum-framework/scalive/releases/download/1.5/scalive-1.5.zip),
+[scalive-1.6.zip](https://github.com/xitrum-framework/scalive/releases/download/1.6/scalive-1.6.zip),
 you will see:
 
 ```
-scalive-1.5/
+scalive-1.6/
   scalive
   scalive.cmd
-  scalive-1.5.jar
+  scalive-1.6.jar
 
-  scala-library-2.10.4.jar
-  scala-compiler-2.10.4.jar
-  scala-reflect-2.10.4.jar
+  scala-library-2.10.6.jar
+  scala-compiler-2.10.6.jar
+  scala-reflect-2.10.6.jar
 
-  scala-library-2.11.4.jar
-  scala-compiler-2.11.4.jar
-  scala-reflect-2.11.4.jar
+  scala-library-2.11.8.jar
+  scala-compiler-2.11.8.jar
+  scala-reflect-2.11.8.jar
 ```
 
-scala-library, scala-compiler, and scala-reflect of the appropriate version
-will be loaded to your running JVM process, if they have not been loaded.
-The REPL console needs these libraries.
+scala-library, scala-compiler, and scala-reflect of the correct version
+that your JVM process is using will be loaded, if they have not been loaded.
+The REPL console needs these libraries to work.
 
-For example, your process has already loaded scala-library 2.10.4 by itself,
+For example, your process has already loaded scala-library 2.11.8 by itself,
 but scala-compiler and scala-reflect haven't been loaded, Scalive will
-automatically load their version 2.10.4.
+automatically load their version 2.11.8.
 
-If none of them has been loaded, Scalive will load version 2.11.4.
+If none of them has been loaded, i.e. your process doesn't use Scala,
+Scalive will load the lastest version in the directory.
 
-For convenience, Scala 2.10.4 and 2.11.4 JARs are preincluded. If your
-process is using a different Scala version, you need to manually download the
-corresponding JARs from the Internet and save them in the same directory as
-above.
+For your convenience, Scala 2.10.6 and 2.11.8 JARs are included above.
+
+If your process is using a different Scala version, you need to manually
+download the corresponding JARs from the Internet and save them in the
+same directory as above.
 
 ## Usage
 
 Run the shell script `scalive` (*nix) or `scalive.cmd` (Windows).
 
-To see a list of running JVM processes and their process IDs:
+Run without argument to see the list of running JVM process IDs on your local machine:
 
 ```
 scalive
@@ -52,25 +54,26 @@ scalive
 To connect a Scala REPL console to a process:
 
 ```
-scalive <pid>
+scalive <process id listed above>
 ```
 
-## How to add your own JARs
+## How to load your own JARs to the process
+
+Scalive only automatically loads `scala-library.jar`, `scala-compiler.jar`,
+`scala-reflect.jar`, and `scalive.jar` to the system classpath.
 
-Scalive only automatically adds `scala-library.jar`, `scala-compiler.jar`,
-`scala-reflect.jar`, and `scalive.jar` to the system classpath. If you want to
-load additional classes in other JARs, first run these in the REPL console to
-add the JAR to the system class loader:
+If you want to load additional classes in other JARs, first run these in the
+REPL console to load the JAR to the system class loader:
 
 ```
-val cl         = ClassLoader.getSystemClassLoader.asInstanceOf[java.net.URLClassLoader]
-val searchDirs = Array("/dir/containing/the/jar")
-val jarbase    = "mylib"  // Will match "mylibxxx.jar", convenient when there's version number in the file name
-scalive.Classpath.findAndAddJar(cl, searchDirs, jarbase)
+val cl            = ClassLoader.getSystemClassLoader.asInstanceOf[java.net.URLClassLoader]
+val jarSearchDirs = Array("/dir/containing/the/jar")
+val jarPrefix     = "mylib"  // Will match "mylib-xxx.jar", convenient when there's version number in the file name
+scalive.Classpath.findAndAddJar(cl, jarSearchDirs, jarPrefix)
 ```
 
 Now the trick is just quit the REPL console and connect it to the target process
-again. You will be able to use your classes in the JAR as normal:
+again. You will be able to use your classes in the JAR normally:
 
 ```
 import mylib.foo.Bar
@@ -81,7 +84,7 @@ import mylib.foo.Bar
 
 ## How Scalive works
 
-Scalive uses the [Attach API](https://blogs.oracle.com/CoreJavaTechTips/entry/the_attach_api)
+Scalive uses the [Attach API](https://blogs.oracle.com/CoreJavaTechTips/entry/the_attach_api) in Java 6
 to tell the target process to load an [agent](http://javahowto.blogspot.jp/2006/07/javaagent-option.html).
 
 The agent then creates a TCP server to let the Scalive process interact with the
@@ -96,13 +99,12 @@ console for Clojure.
 
 For simplicity and to avoid memory leak when you attach/detach many times,
 Scalive only supports processes with only the default system class loader,
-without additional class loaders (Ex: normal standalone JVM processes, like
+without additional class loaders. Usually they are standalone JVM processes,
+like
 [Play](http://www.playframework.com/) or
-[Xitrum](http://xitrum-framework.github.io/) in production mode).
+[Xitrum](http://xitrum-framework.github.io/) in production mode.
 
-Processes with multiple class loaders like Tomcat or
-[SBT](http://www.scala-sbt.org/) are not supported (with SBT, you already has
-the SBT console, so it's not a big deal).
+Processes with multiple class loaders like Tomcat are currently not supported.
 
 2.
 

build.sbt

@@ -1,18 +1,16 @@
 organization := "tv.cntt"
 name         := "scalive"
-version      := "1.5-SNAPSHOT"
+version      := "1.6"
 
 scalaVersion        := "2.11.6"
-libraryDependencies += "org.scala-lang" % "scala-compiler" % "2.11.6" % "provided"
+libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value % "provided"
 autoScalaLibrary    := false
 crossPaths          := false  // Do not append Scala versions to the generated artifacts
 
 javacOptions ++= Seq("-Xlint:deprecation")
 
 // Ensure Scalive can run on Java 6
 scalacOptions += "-target:jvm-1.6"
-
-// Ensure Scalive can run on Java 6
 javacOptions ++= Seq("-source", "1.6", "-target", "1.6")
 
 // Add tools.jar to classpath

dev/README.rst

@@ -25,21 +25,21 @@ This is the directory that will be zipped when Scalive is released.
   zip/
     scalive
     scalive.cmd
-    scalive-<version>-SNAPSHOT.jar -> ../../target/scala-2.11/scalive-<version>-SNAPSHOT.jar
+    scalive-<version>.jar -> ../../target/scala-2.11/scalive-<version>.jar
 
-    scala-library-2.10.4.jar
-    scala-compiler-2.10.4.jar
-    scala-reflect-2.10.4.jar
+    scala-library-2.10.6.jar
+    scala-compiler-2.10..jar
+    scala-reflect-2.10.6.jar
 
-    scala-library-2.11.4.jar
-    scala-compiler-2.11.4.jar
-    scala-reflect-2.11.4.jar
+    scala-library-2.11.8.jar
+    scala-compiler-2.11.8.jar
+    scala-reflect-2.11.8.jar
 
 While developing:
 
-* Run ``sbt package`` to create/update scalive.jar.
+* Run ``sbt package`` to create/update scalive-<version>.jar.
 * Add missing JARs as above.
-* Run ``scalive`` to attach to a certain JVM process to see if it works properly.
+* Run ``scalive`` to attach to a JVM process to see if it works properly.
 
 Release
 -------

src/main/java/scalive/Agent.java

@@ -7,25 +7,23 @@
 
 public class Agent {
     /**
-     * @param agentArgs <jarpath1>[<File.pathSeparator><jarpath2>...] <server port>
+     * @param agentArgs <jarSearchDir1>[<File.pathSeparator><jarSearchDir2>...] <server port>
      *
-     * jarpath is the absolute path this directory:
-     *
-     * {{{
-     * jarpath/
+     * <pre>{@code
+     * jarSearchDir/
      *   scalive.jar
      *
      *   scala-library-2.11.0.jar
      *   scala-compiler-2.11.0.jar
      *   scala-reflect-2.11.0.jar
      *
      *   [Other Scala versions]
-     * }}}
+     * }</pre>
      */
     public static void agentmain(String agentArgs, Instrumentation inst) throws Exception {
-        final String[] args     = agentArgs.split(" ");
-        final String[] jarpaths = args[0].split(File.pathSeparator);
-        final int      port     = Integer.parseInt(args[1]);
+        final String[] args          = agentArgs.split(" ");
+        final String[] jarSearchDirs = args[0].split(File.pathSeparator);
+        final int      port          = Integer.parseInt(args[1]);
 
         System.out.println("[Scalive] REPL server starts at port " + port);
         final ServerSocket server = new ServerSocket(port);
@@ -42,7 +40,7 @@ public void run() {
                 try {
                     Socket client = server.accept();  // Block until a connection comes in
                     server.close();                   // Accept no other clients
-                    Server.serve(client, jarpaths);
+                    Server.serve(client, jarSearchDirs);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }

src/main/java/scalive/AgentLoader.java

@@ -10,24 +10,22 @@
 
 public class AgentLoader {
     /**
-     * @param args <jarpath1>[<File.pathSeparator><jarpath2>...] [pid]
+     * @param args <jarSearchDir1>[<File.pathSeparator><jarSearchDir2>...] [pid]
      *
-     * jarpath is the absolute path this directory:
-     *
-     * {{{
-     * jarpath/
+     * <pre>{@code
+     * jarSearchDir/
      *   scalive.jar
      *
      *   scala-library-2.11.0.jar
      *   scala-compiler-2.11.0.jar
      *   scala-reflect-2.11.0.jar
      *
      *   [Other Scala versions]
-     * }}}
+     * }</pre>
      */
     public static void main(String[] args) throws Exception {
         if (args.length != 1 && args.length != 2) {
-            System.out.println("Arguments: <jarpath1>[<File.pathSeparator><jarpath2>...] [pid]");
+            System.out.println("Arguments: <jarSearchDir1>[<File.pathSeparator><jarSearchDir2>...] [pid]");
             return;
         }
 
@@ -38,16 +36,16 @@ public static void main(String[] args) throws Exception {
             return;
         }
 
-        String jarpaths = args[0];
+        String jarSearchDirs = args[0];
         String pid      = args[1];
-        loadAgent(jarpaths, pid);
+        loadAgent(jarSearchDirs, pid);
     }
 
     /**
      * com.sun.tools.attach.VirtualMachine is in tools.jar, which is not in
      * classpath by default:
      *
-     * {{{
+     * <pre>{@code
      * jdk/
      *   bin/
      *     java
@@ -56,7 +54,7 @@ public static void main(String[] args) throws Exception {
      *     java
      *   lib/
      *     tools.jar
-     * }}}
+     * }</pre>
      */
     private static void addToolsDotJarToClasspath() throws Exception {
         String path = System.getProperty("java.home") + "/../lib/tools.jar";
@@ -74,13 +72,13 @@ private static void listJvmProcesses() {
         }
     }
 
-    private static void loadAgent(String jarpaths, String pid) throws Exception {
-        final String[]       ary      = jarpaths.split(File.pathSeparator);
+    private static void loadAgent(String jarSearchDirs, String pid) throws Exception {
+        final String[]       ary      = jarSearchDirs.split(File.pathSeparator);
         final String         agentJar = Classpath.findJar(ary, "scalive");
         final VirtualMachine vm       = VirtualMachine.attach(pid);
         final int            port     = Client.getFreePort();
 
-        vm.loadAgent(agentJar, jarpaths + " " + port);
+        vm.loadAgent(agentJar, jarSearchDirs + " " + port);
         Runtime.getRuntime().addShutdownHook(new Thread() {
             @Override public void run() {
                 try {

src/main/java/scalive/Classpath.java

@@ -24,24 +24,35 @@ private static Method getAddURL() {
     //--------------------------------------------------------------------------
 
     /**
-     * @param jarpaths Directories to search for the JAR
+     * Finds the ".jar" file with the {@code jarPrefix} and the latest version.
      *
-     * @param jarbase JAR file name prefix; Ex: "scalive-agent" will match "scalive-agent-xxx.jar"
+     * @param jarSearchDirs Directories to search for the JAR
+     *
+     * @param jarPrefix JAR file name prefix to search; example: "scalive-agent" will match "scalive-agent-xxx.jar"
      */
-    public static String findJar(String[] jarpaths, String jarbase) throws Exception {
-        for (String jarpath: jarpaths) {
-            File   dir   = new File(jarpath);
+    public static String findJar(String[] jarSearchDirs, String jarPrefix) throws Exception {
+        String maxBaseName = null;
+        File   maxFile     = null;
+        for (String jarSearchDir: jarSearchDirs) {
+            File dir     = new File(jarSearchDir);
             File[] files = dir.listFiles();
+            if (files == null) continue;
 
-            for (int i = 0; i < files.length; i++) {
-                File   file = files[i];
-                String name = file.getName();
-                if (file.isFile() && name.endsWith(".jar") && name.startsWith(jarbase))
-                    return file.getPath();
+            for (File file : files) {
+                String baseName = file.getName();
+                if (file.isFile() && baseName.endsWith(".jar") && baseName.startsWith(jarPrefix)) {
+                    if (maxBaseName == null || baseName.compareTo(maxBaseName) > 0) {
+                        maxBaseName = baseName;
+                        maxFile     = file;
+                    }
+                }
             }
         }
 
-        throw new Exception("Could not find " + jarbase + " in " + join(jarpaths, File.pathSeparator));
+        if (maxFile == null)
+            throw new Exception("Could not find " + jarPrefix + " in " + join(jarSearchDirs, File.pathSeparator));
+        else
+            return maxFile.getPath();
     }
 
     public static void addPath(URLClassLoader cl, String path) throws Exception {
@@ -50,24 +61,24 @@ public static void addPath(URLClassLoader cl, String path) throws Exception {
         if (!Arrays.asList(urls).contains(url)) addURL.invoke(cl, url);
     }
 
-    /** Combination of findJar and addPath. */
-    public static void findAndAddJar(URLClassLoader cl, String[] jarpaths, String jarbase) throws Exception {
-        String jar = findJar(jarpaths, jarbase);
+    /** Combination of {@link #findJar(String[], String)} and {@link #addPath(URLClassLoader, String)}. */
+    public static void findAndAddJar(URLClassLoader cl, String[] jarSearchDirs, String jarPrefix) throws Exception {
+        String jar = findJar(jarSearchDirs, jarPrefix);
         addPath(cl, jar);
+        System.out.println("[Scalive] Load " + jar);
     }
 
     /**
-     * Similar to findAndAddJar without representativeClass, but only find and
-     * add the JAR to classpath if the representativeClass has not been loaded.
+     * Similar to {@link #findAndAddJar(URLClassLoader, String[], String)} without {@code representativeClass},
+     * but only find and add the JAR to classpath if the representativeClass has not been loaded.
      */
     public static void findAndAddJar(
-        URLClassLoader cl, String[] jarpaths, String jarbase, String representativeClass
+        URLClassLoader cl, String representativeClass, String[] jarSearchDirs, String jarPrefix
     ) throws Exception {
         try {
             Class.forName(representativeClass, true, cl);
         } catch (ClassNotFoundException e) {
-            System.out.println("[Scalive] Load " + jarbase);
-            findAndAddJar(cl, jarpaths, jarbase);
+            findAndAddJar(cl, jarSearchDirs, jarPrefix);
         }
     }
 
@@ -86,11 +97,11 @@ public static String getScalaVersion(ClassLoader cl) throws Exception {
     //--------------------------------------------------------------------------
 
     private static String join(Object[] xs, String separator) {
-        StringBuffer buf = new StringBuffer();
+        StringBuilder b = new StringBuilder();
         for (Object x: xs) {
-            if (buf.length() > 0) buf.append(separator);
-            buf.append(x);
+            if (b.length() > 0) b.append(separator);
+            b.append(x);
         }
-        return buf.toString();
+        return b.toString();
     }
 }