warbler 1.3.6 → 1.3.7

data/ext/WarMain.java

@@ -5,16 +5,22 @@
  * See the file LICENSE.txt for details.
  */
 
-import java.net.URLClassLoader;
-import java.net.URL;
 import java.lang.reflect.Method;
-import java.io.IOException;
 import java.io.InputStream;
+import java.io.ByteArrayInputStream;
+import java.io.SequenceInputStream;
 import java.io.File;
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
+import java.net.URI;
+import java.net.URLClassLoader;
+import java.net.URL;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Properties;
 import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.Set;
 
 /**
  * Used as a Main-Class in the manifest for a .war file, so that you can run
@@ -52,32 +58,48 @@ import java.util.Map;
  * jetty.home = {{webroot}}
  * </pre>
  */
-public class WarMain implements Runnable {
-    public static final String MAIN = "/" + WarMain.class.getName().replace('.', '/') + ".class";
-    public static final String WEBSERVER_PROPERTIES = "/WEB-INF/webserver.properties";
-    public static final String WEBSERVER_JAR = "/WEB-INF/webserver.jar";
-
-    private String[] args;
-    private String path, warfile;
-    private boolean debug;
+public class WarMain extends JarMain {
+    
+    static final String MAIN = "/" + WarMain.class.getName().replace('.', '/') + ".class";
+    static final String WEBSERVER_PROPERTIES = "/WEB-INF/webserver.properties";
+    static final String WEBSERVER_JAR = "/WEB-INF/webserver.jar";
+    
+    // jruby arguments, consider the following command :
+    //   `java -jar rails.was --1.9 -S rake db:migrate`
+    // arguments == [ "--1.9" ]
+    // executable == "rake"
+    // executableArgv == [ "db:migrate" ]
+    private final String[] arguments;
+    // null to launch webserver or != null to run a executable e.g. rake
+    private final String executable;
+    private final String[] executableArgv;
+            
     private File webroot;
 
-    public WarMain(String[] args) throws Exception {
-        this.args = args;
-        URL mainClass = getClass().getResource(MAIN);
-        this.path = mainClass.toURI().getSchemeSpecificPart();
-        this.warfile = this.path.replace("!" + MAIN, "").replace("file:", "");
-        this.debug = isDebug();
+    WarMain(final String[] args) {
+        super(args);
+        final List<String> argsList = Arrays.asList(args);
+        final int sIndex = argsList.indexOf("-S");
+        if ( sIndex == -1 ) {
+            executable = null; executableArgv = null; arguments = null;
+        }
+        else {
+            if ( args.length == sIndex + 1 || args[sIndex + 1].isEmpty() ) {
+                throw new IllegalArgumentException("missing executable after -S");
+            }
+            arguments = argsList.subList(0, sIndex).toArray(new String[0]);
+            executable = argsList.get(sIndex + 1);
+            executableArgv = argsList.subList(sIndex + 2, argsList.size()).toArray(new String[0]);
+        }
+    }
+    
+    private URL extractWebserver() throws Exception {
         this.webroot = File.createTempFile("warbler", "webroot");
         this.webroot.delete();
         this.webroot.mkdirs();
-        this.webroot = new File(this.webroot, new File(warfile).getName());
+        this.webroot = new File(this.webroot, new File(archive).getName());
         debug("webroot directory is " + this.webroot.getPath());
-        Runtime.getRuntime().addShutdownHook(new Thread(this));
-    }
-
-    private URL extractWebserver() throws Exception {
-        InputStream jarStream = new URL("jar:" + path.replace(MAIN, WEBSERVER_JAR)).openStream();
+        InputStream jarStream = new URI("jar", entryPath(WEBSERVER_JAR), null).toURL().openStream();
         File jarFile = File.createTempFile("webserver", ".jar");
         jarFile.deleteOnExit();
         FileOutputStream outStream = new FileOutputStream(jarFile);
@@ -99,13 +121,12 @@ public class WarMain implements Runnable {
         Properties props = new Properties();
         try {
             InputStream is = getClass().getResourceAsStream(WEBSERVER_PROPERTIES);
-            props.load(is);
-        } catch (Exception e) {
-        }
+            if ( is != null ) props.load(is);
+        } catch (Exception e) { }
 
         for (Map.Entry entry : props.entrySet()) {
             String val = (String) entry.getValue();
-            val = val.replace("{{warfile}}", warfile).replace("{{webroot}}", webroot.getAbsolutePath());
+            val = val.replace("{{warfile}}", archive).replace("{{webroot}}", webroot.getAbsolutePath());
             entry.setValue(val);
         }
 
@@ -119,7 +140,7 @@ public class WarMain implements Runnable {
         return props;
     }
 
-    private void launchWebserver(URL jar) throws Exception {
+    private void launchWebServer(URL jar) throws Exception {
         URLClassLoader loader = new URLClassLoader(new URL[] {jar});
         Thread.currentThread().setContextClassLoader(loader);
         Properties props = getWebserverProperties();
@@ -130,66 +151,174 @@ public class WarMain implements Runnable {
                                                + " is missing 'mainclass' property)");
         }
         Class klass = Class.forName(mainClass, true, loader);
-        Method main = klass.getDeclaredMethod("main", new Class[] {String[].class});
-        String[] newargs = launchArguments(props);
-        debug("invoking webserver with: " + Arrays.deepToString(newargs));
-        main.invoke(null, new Object[] {newargs});
+        Method main = klass.getDeclaredMethod("main", new Class[] { String[].class });
+        String[] newArgs = launchWebServerArguments(props);
+        debug("invoking webserver with: " + Arrays.deepToString(newArgs));
+        main.invoke(null, new Object[] { newArgs });
+
+        // the following code is specific to winstone. but a whole winstone module like the jetty module seemed
+        // excessive. if running under jetty (or anything other than wintstone) this will effectively do nothing.
+        Set<Thread> threads = Thread.getAllStackTraces().keySet();
+        for (Thread thread : threads) {
+            String name = thread.getName();
+            if (name.startsWith("LauncherControlThread")) {
+                debug("joining thread: " + name);
+                thread.join();
+            }
+        }
     }
 
-    private String[] launchArguments(Properties props) {
-        String[] newargs = args;
+    private String[] launchWebServerArguments(Properties props) {
+        String[] newArgs = args;
 
         if (props.getProperty("args") != null) {
             String[] insertArgs = props.getProperty("args").split(",");
-            newargs = new String[args.length + insertArgs.length];
+            newArgs = new String[args.length + insertArgs.length];
             for (int i = 0; i < insertArgs.length; i++) {
-                newargs[i] = props.getProperty(insertArgs[i], "");
+                newArgs[i] = props.getProperty(insertArgs[i], "");
             }
-            System.arraycopy(args, 0, newargs, insertArgs.length, args.length);
+            System.arraycopy(args, 0, newArgs, insertArgs.length, args.length);
         }
 
-        return newargs;
+        return newArgs;
     }
 
-    private void start() throws Exception {
-        URL u = extractWebserver();
-        launchWebserver(u);
+    // JarMain overrides to make WarMain "launchable" 
+    // e.g. java -jar rails.war -S rake db:migrate
+    
+    @Override
+    protected String getExtractEntryPath(final JarEntry entry) {
+        final String name = entry.getName();
+        final String start = "WEB-INF";
+        if ( name.startsWith(start) ) {
+            // WEB-INF/app/controllers/application_controller.rb -> 
+            // app/controllers/application_controller.rb
+            return name.substring(start.length());
+        }
+        if ( name.indexOf('/') == -1 ) {
+            // 404.html -> public/404.html
+            return "/public/" + name;
+        }
+        return "/" + name;
     }
-
-    private void debug(String msg) {
-        if (debug) {
-            System.out.println(msg);
+    
+    @Override
+    protected URL extractEntry(final JarEntry entry, final String path) throws Exception {
+        // always extract but only return class-path entry URLs :
+        final URL entryURL = super.extractEntry(entry, path);
+        return path.endsWith(".jar") ? entryURL : null;
+    }
+    
+    @Override
+    protected int launchJRuby(final URL[] jars) throws Exception {
+        final Object scriptingContainer = newScriptingContainer(jars);
+        
+        invokeMethod(scriptingContainer, "setArgv", (Object) executableArgv);
+        //invokeMethod(scriptingContainer, "setHomeDirectory", "classpath:/META-INF/jruby.home");
+        invokeMethod(scriptingContainer, "setCurrentDirectory", extractRoot.getAbsolutePath());
+        //invokeMethod(scriptingContainer, "runScriptlet", "ENV.clear");
+        //invokeMethod(scriptingContainer, "runScriptlet", "ENV['PATH']=''"); // bundler 1.1.x
+        
+        final Object provider = invokeMethod(scriptingContainer, "getProvider");
+        final Object rubyInstanceConfig = invokeMethod(provider, "getRubyInstanceConfig");
+        
+        invokeMethod(rubyInstanceConfig, "setUpdateNativeENVEnabled", new Class[] { Boolean.TYPE }, false);
+        
+        final String executablePath = locateExecutable(scriptingContainer);
+        if ( executablePath == null ) {
+            throw new IllegalStateException("failed to locate gem executable: '" + executable + "'");
+        }
+        invokeMethod(scriptingContainer, "setScriptFilename", executablePath);
+        
+        invokeMethod(rubyInstanceConfig, "processArguments", (Object) arguments);
+        
+        Object runtime = invokeMethod(scriptingContainer, "getRuntime");
+        Object executableInput =
+            new SequenceInputStream(new ByteArrayInputStream(executableScriptEnvPrefix().getBytes()),
+                                    (InputStream) invokeMethod(rubyInstanceConfig, "getScriptSource"));
+        
+        debug("invoking " + executablePath + " with: " + Arrays.toString(executableArgv));
+        Object outcome = invokeMethod(runtime, "runFromMain", 
+                new Class[] { InputStream.class, String.class }, 
+                executableInput, executablePath 
+        );
+        return ( outcome instanceof Number ) ? ( (Number) outcome ).intValue() : 0;
+    }
+    
+    protected String locateExecutable(final Object scriptingContainer) throws Exception {
+        if ( executable == null ) {
+            throw new IllegalStateException("no executable");
+        }
+        final File exec = new File(extractRoot, executable);
+        if ( exec.exists() ) {
+            return exec.getAbsolutePath();
         }
+        else {
+            final String script = locateExecutableScript(executable);
+            return (String) invokeMethod(scriptingContainer, "runScriptlet", script);
+        }
+    }
+    protected String executableScriptEnvPrefix() {
+        final String gemsDir = new File(extractRoot, "gems").getAbsolutePath();
+        final String gemfile = new File(extractRoot, "Gemfile").getAbsolutePath();
+        debug("setting GEM_HOME to " + gemsDir);
+        debug("... and BUNDLE_GEMFILE to " + gemfile);
+        return "ENV['GEM_HOME'] ||= ENV['GEM_PATH'] = '"+ gemsDir +"' \n" +
+        "ENV['BUNDLE_GEMFILE'] ||= '"+ gemfile +"' \n" +
+        "require 'META-INF/init.rb' \n";
     }
 
-    private void delete(File f) {
-        if (f.isDirectory()) {
-            File[] children = f.listFiles();
-            for (int i = 0; i < children.length; i++) {
-                delete(children[i]);
+    protected String locateExecutableScript(final String executable) {
+        return executableScriptEnvPrefix() +
+        "begin\n" +
+        // locate the executable within gemspecs :
+        "  require 'rubygems' \n" +
+            "  begin\n" +
+            // add bundler gems to load path:
+            "    require 'bundler' \n" +
+            // TODO: environment from web.xml. Any others?
+            "    Bundler.setup(:default, *ENV.values_at('RACK_ENV', 'RAILS_ENV').compact)\n" +
+            "  rescue LoadError\n" +
+            // bundler not used
+            "  end\n" +
+        "  exec = '"+ executable +"' \n" +
+        "  spec = Gem::Specification.find { |s| s.executables.include?(exec) } \n" +
+        "  spec ? spec.bin_file(exec) : nil \n" +
+        // returns the full path to the executable
+        "rescue SystemExit => e\n" +
+        "  e.status\n" +
+        "end";
+    }
+    
+    @Override
+    protected int start() throws Exception {
+        if ( executable == null ) {
+            try {
+                URL server = extractWebserver();
+                launchWebServer(server);
+            }
+            catch (FileNotFoundException e) {
+                if ( e.getMessage().indexOf("WEB-INF/webserver.jar") > -1 ) {
+                    System.out.println("specify the -S argument followed by the bin file to run e.g. `java -jar rails.war -S rake -T` ...");
+                    System.out.println("(or if you'd like your .war file to start a web server package it using `warbler executable war`)");
+                }
+                throw e;
             }
+            return 0;
+        }
+        else {
+            return super.start();
         }
-        f.delete();
     }
 
+    @Override
     public void run() {
-        delete(webroot.getParentFile());
+        super.run();
+        if ( webroot != null ) delete(webroot.getParentFile());
     }
 
     public static void main(String[] args) {
-        try {
-            new WarMain(args).start();
-        } catch (Exception e) {
-            System.err.println("error: " + e.toString());
-            if (isDebug()) {
-                e.printStackTrace();
-            }
-            System.exit(1);
-        }
+        doStart(new WarMain(args));
     }
 
-    private static boolean isDebug() {
-        return System.getProperty("warbler.debug") != null;
-    }
 }
-

data/ext/WarblerJar.java

@@ -168,11 +168,21 @@ public class WarblerJar {
         return entryInJar(stream, entry);
     }
 
+    private static String trimTrailingSlashes(String path) {
+        if (path.endsWith("/")) {
+            return path.substring(0, path.length() - 1);
+        } else {
+            return path;
+        }
+    }
+
     private static InputStream entryInJar(InputStream jar, String entry) throws IOException {
+        entry = trimTrailingSlashes(entry);
+
         ZipInputStream jstream = new ZipInputStream(jar);
         ZipEntry zentry = null;
         while ((zentry = jstream.getNextEntry()) != null) {
-            if (zentry.getName().equals(entry)) {
+            if (trimTrailingSlashes(zentry.getName()).equals(entry)) {
                 return jstream;
             }
             jstream.closeEntry();

data/lib/warbler.rb

@@ -9,7 +9,8 @@
 # your Ruby applications into .jar or .war files.
 module Warbler
   WARBLER_HOME = File.expand_path(File.dirname(__FILE__) + '/..') unless defined?(WARBLER_HOME)
-
+  WARBLER_JAR = "#{WARBLER_HOME}/lib/warbler_jar.jar" unless defined?(WARBLER_JAR)
+  
   class << self
     # An instance of Warbler::Application used by the +warble+ command.
     attr_accessor :application

data/lib/warbler/application.rb

@@ -37,9 +37,12 @@ class Warbler::Application < Rake::Application
     desc "Feature: package gem repository inside a jar"
     task :gemjar => "#{wt.name}:gemjar"
 
-    desc "Feature: make an executable archive"
+    desc "Feature: make an executable archive (runnable + an embedded web server)"
     task :executable => "#{wt.name}:executable"
 
+    desc "Feature: make a runnable archive (e.g. java -jar rails.war -S rake db:migrate)"
+    task :runnable => "#{wt.name}:runnable"
+    
     desc "Feature: precompile all Ruby files"
     task :compiled => "#{wt.name}:compiled"
 

data/lib/warbler/config.rb

@@ -14,7 +14,7 @@ module Warbler
   class Config
     include RakeHelper
 
-    TOP_DIRS = %w(app config lib log vendor)
+    TOP_DIRS = %w(app db config lib log script vendor)
     FILE = "config/warble.rb"
     BUILD_GEMS = %w(warbler rake rcov)
 
@@ -96,7 +96,7 @@ module Warbler
     attr_accessor :bundler
 
     # An array of Bundler groups to avoid including in the war file.
-    # Defaults to ["development", "test"].
+    # Defaults to ["development", "test", "assets"].
     attr_accessor :bundle_without
 
     # Path to the pre-bundled gem directory inside the war file. Default is '/WEB-INF/gems'.
@@ -115,6 +115,12 @@ module Warbler
     # If the filename ends in .erb the file will be expanded the same way web.xml.erb is; see below.
     attr_accessor :init_contents
 
+    # Override GEM_HOME environment variable at runtime. When false, gems in
+    # GEM_HOME will be loaded in preference to those packaged within the jar
+    # file. When true, only gems packaged in the jar file will be loaded.
+    # Defaults to false
+    attr_accessor :override_gem_home
+
     # Extra configuration for web.xml. Controls how the dynamically-generated web.xml
     # file is generated.
     #
@@ -158,7 +164,7 @@ module Warbler
       @warbler_templates = "#{WARBLER_HOME}/lib/warbler/templates"
       @features          = Set.new
       @dirs              = TOP_DIRS.select {|d| File.directory?(d)}
-      @includes          = FileList[]
+      @includes          = FileList['*file'] # [r/R]akefile gets included
       @excludes          = FileList[]
       @java_libs         = FileList[]
       @java_classes      = FileList[]
@@ -172,6 +178,7 @@ module Warbler
       @webinf_files      = FileList[]
       @init_filename     = 'META-INF/init.rb'
       @init_contents     = ["#{@warbler_templates}/config.erb"]
+      @override_gem_home = false
 
       before_configure
       yield self if block_given?
@@ -180,6 +187,7 @@ module Warbler
       @compiled_ruby_files ||= FileList[*@dirs.map {|d| "#{d}/**/*.rb"}]
 
       @excludes += ["tmp/war", "tmp/war/**/*"] if File.directory?("tmp/war")
+      @excludes += ["tmp/cache/**/*"] if File.directory?("tmp/cache")
       @excludes += warbler_vendor_excludes(warbler_home)
       @excludes += FileList["**/*.log"] if @exclude_logs
     end
@@ -199,6 +207,9 @@ module Warbler
       task "executable" do
         self.features << "executable"
       end
+      task "runnable" do
+        self.features << "runnable"
+      end
     end
 
     # Deprecated

data/lib/warbler/jar.rb

@@ -44,8 +44,13 @@ module Warbler
     end
 
     def run_javac(config, compiled_ruby_files)
+      if config.webxml && config.webxml.context_params.has_key?('jruby.compat.version')
+        compat_version = "--#{config.webxml.jruby.compat.version}"
+      else
+        compat_version = ''
+      end
       # Need to use the version of JRuby in the application to compile it
-      %x{java -classpath #{config.java_libs.join(File::PATH_SEPARATOR)} org.jruby.Main -S jrubyc \"#{compiled_ruby_files.join('" "')}\"}
+      %x{java -classpath #{config.java_libs.join(File::PATH_SEPARATOR)} org.jruby.Main #{compat_version} -S jrubyc \"#{compiled_ruby_files.join('" "')}\"}
     end
 
     def replace_compiled_ruby_files(config, compiled_ruby_files)
@@ -54,7 +59,7 @@ module Warbler
       config.excludes += compiled_ruby_files
 
       compiled_ruby_files.each do |ruby_source|
-        files[apply_pathmaps(config, ruby_source, :application)] = StringIO.new("require __FILE__.sub(/\.rb$/, '.class')")
+        files[apply_pathmaps(config, ruby_source, :application)] = StringIO.new("load __FILE__.sub(/\.rb$/, '.class')")
       end
     end
 
@@ -81,6 +86,9 @@ module Warbler
       rm_f path
       ensure_directory_entries
       puts "Creating #{path}"
+      if Warbler::Config === config_or_path
+        @files.delete("#{config_or_path.jar_name}/#{path}")
+      end
       create_jar path, @files
     end