lucidimagination-warbler 1.3.2.dev

data/Rakefile

@@ -0,0 +1,103 @@
+#--
+# Copyright (c) 2010-2011 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts "Please install Bundler and run 'bundle install' to ensure you have all dependencies"
+end
+
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", "Gemfile",
+                    "LICENSE.txt", "Rakefile", "*.erb", "*.rb", "bin/*",
+                    "ext/**/*", "lib/**/*", "spec/**/*.rb", "spec/sample*/**/*.*"
+                   ].to_a.reject{|f| f=~%r{spec/sample/(MANIFEST|link|web.xml)}}.sort.uniq
+
+begin
+  File.open("Manifest.txt", "wb") {|f| MANIFEST.each {|n| f << "#{n}\n"} }
+  require 'hoe'
+  require File.dirname(__FILE__) + '/lib/warbler/version'
+  Hoe.plugin :rubyforge
+  hoe = Hoe.spec("warbler") do |p|
+    p.version = Warbler::VERSION
+    p.rubyforge_name = "caldersphere"
+    p.url = "http://caldersphere.rubyforge.org/warbler"
+    p.author = "Nick Sieger"
+    p.email = "nick@nicksieger.com"
+    p.summary = "Warbler chirpily constructs .war files of your Rails applications."
+    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    p.description = p.paragraphs_of('README.txt', 1...2).join("\n\n")
+    p.extra_deps += [['rake', '~> 0.8.7'], ['jruby-jars', '>= 1.4.0'], ['jruby-rack', '>= 1.0.0'], ['rubyzip', '>= 0.9.4']]
+    p.clean_globs += %w(MANIFEST web.xml init.rb).map{|f| "spec/sample*/#{f}*" }
+  end
+  hoe.spec.files = MANIFEST
+  hoe.spec.rdoc_options += ["-SHN", "-f", "darkfish"]
+
+  task :gemspec do
+    File.open("#{hoe.name}.gemspec", "w") {|f| f << hoe.spec.to_ruby }
+  end
+  task :package => :gemspec
+rescue LoadError
+  puts "You really need Hoe installed to be able to package this gem"
+end
+
+# Leave my tasks alone, Hoe
+%w(default spec rcov).each do |task|
+  Rake::Task[task].prerequisites.clear
+  Rake::Task[task].actions.clear
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts ||= []
+  t.spec_opts << "--options" << "spec/spec.opts"
+end
+
+Spec::Rake::SpecTask.new("spec:rcov") do |t|
+  t.spec_opts ||= []
+  t.spec_opts << "--options" << "spec/spec.opts"
+  t.rcov_opts ||= []
+  t.rcov_opts << "-x" << "/gems/"
+  t.rcov = true
+end
+
+RCov::VerifyTask.new(:rcov => "spec:rcov") do |t|
+  t.threshold = 100
+end
+
+task :default => :spec
+
+desc "Compile and jar the Warbler Java helper classes"
+begin
+  require 'ant'
+  task :jar => :compile do
+    ant.jar :basedir => "pkg/classes", :destfile => "lib/warbler_jar.jar", :includes => "*.class"
+  end
+
+  directory "pkg/classes"
+  task :compile => "pkg/classes" do |t|
+    ant.javac :srcdir => "ext", :destdir => t.prerequisites.first,
+    :source => "1.5", :target => "1.5", :debug => true,
+    :classpath => "${java.class.path}:${sun.boot.class.path}",
+    :includeantRuntime => false
+  end
+rescue LoadError
+  task :jar do
+    puts "Run 'jar' with JRuby >= 1.5 to re-compile the java jar booster"
+  end
+end
+
+# Make sure jar gets compiled before the gem is built
+task Rake::Task['gem'].prerequisites.first => :jar
+
+task :warbler_jar => 'pkg' do
+  ruby "-rubygems", "-Ilib", "-S", "bin/warble"
+  mv "warbler.jar", "pkg/warbler-#{Warbler::VERSION}.jar"
+end
+
+task :package => :warbler_jar

data/bin/warble

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+#
+#--
+# Copyright (c) 2010-2011 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'warbler'
+Warbler::Application.new.run

data/ext/JarMain.java

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2010-2011 Engine Yard, Inc.
+ * Copyright (c) 2007-2009 Sun Microsystems, Inc.
+ * This source code is available under the MIT license.
+ * See the file LICENSE.txt for details.
+ */
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class JarMain implements Runnable {
+    public static final String MAIN = "/" + JarMain.class.getName().replace('.', '/') + ".class";
+
+    private String[] args;
+    private String path, jarfile;
+    private boolean debug;
+    private File extractRoot;
+
+    public JarMain(String[] args) throws Exception {
+        this.args = args;
+        URL mainClass = getClass().getResource(MAIN);
+        this.path = mainClass.toURI().getSchemeSpecificPart();
+        this.jarfile = this.path.replace("!" + MAIN, "").replace("file:", "");
+        this.debug = isDebug();
+        this.extractRoot = File.createTempFile("jruby", "extract");
+        this.extractRoot.delete();
+        this.extractRoot.mkdirs();
+        Runtime.getRuntime().addShutdownHook(new Thread(this));
+    }
+
+    private URL[] extractJRuby() throws Exception {
+        JarFile jf = new JarFile(this.jarfile);
+        List<String> jarNames = new ArrayList<String>();
+        for (Enumeration<JarEntry> eje = jf.entries(); eje.hasMoreElements(); ) {
+            String name = eje.nextElement().getName();
+            if (name.startsWith("META-INF/lib") && name.endsWith(".jar")) {
+                jarNames.add("/" + name);
+            }
+        }
+
+        List<URL> urls = new ArrayList<URL>();
+        for (String name : jarNames) {
+            urls.add(extractJar(name));
+        }
+
+        return (URL[]) urls.toArray(new URL[urls.size()]);
+    }
+
+    private URL extractJar(String jarpath) throws Exception {
+        InputStream jarStream = new URL("jar:" + path.replace(MAIN, jarpath)).openStream();
+        String jarname = jarpath.substring(jarpath.lastIndexOf("/") + 1, jarpath.lastIndexOf("."));
+        File jarFile = new File(extractRoot, jarname + ".jar");
+        jarFile.deleteOnExit();
+        FileOutputStream outStream = new FileOutputStream(jarFile);
+        try {
+            byte[] buf = new byte[65536];
+            int bytesRead = 0;
+            while ((bytesRead = jarStream.read(buf)) != -1) {
+                outStream.write(buf, 0, bytesRead);
+            }
+        } finally {
+            jarStream.close();
+            outStream.close();
+        }
+        debug(jarname + ".jar extracted to " + jarFile.getPath());
+        return jarFile.toURI().toURL();
+    }
+
+    private int launchJRuby(URL[] jars) throws Exception {
+        System.setProperty("org.jruby.embed.class.path", "");
+        URLClassLoader loader = new URLClassLoader(jars);
+        Class scriptingContainerClass = Class.forName("org.jruby.embed.ScriptingContainer", true, loader);
+        Object scriptingContainer = scriptingContainerClass.newInstance();
+
+        Method argv = scriptingContainerClass.getDeclaredMethod("setArgv", new Class[] {String[].class});
+        argv.invoke(scriptingContainer, new Object[] {args});
+        Method setClassLoader = scriptingContainerClass.getDeclaredMethod("setClassLoader", new Class[] {ClassLoader.class});
+        setClassLoader.invoke(scriptingContainer, new Object[] {loader});
+        debug("invoking " + jarfile + " with: " + Arrays.deepToString(args));
+
+        Method runScriptlet = scriptingContainerClass.getDeclaredMethod("runScriptlet", new Class[] {String.class});
+        return ((Number) runScriptlet.invoke(scriptingContainer, new Object[] {
+                    "begin\n" +
+                    "require 'META-INF/init.rb'\n" +
+                    "require 'META-INF/main.rb'\n" +
+                    "0\n" +
+                    "rescue SystemExit => e\n" +
+                    "e.status\n" +
+                    "end"
+                })).intValue();
+    }
+
+    private int start() throws Exception {
+        URL[] u = extractJRuby();
+        return launchJRuby(u);
+    }
+
+    private void debug(String msg) {
+        if (debug) {
+            System.out.println(msg);
+        }
+    }
+
+    private void delete(File f) {
+        if (f.isDirectory()) {
+            File[] children = f.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                delete(children[i]);
+            }
+        }
+        f.delete();
+    }
+
+    public void run() {
+        delete(extractRoot);
+    }
+
+    public static void main(String[] args) {
+        try {
+            int exit = new JarMain(args).start();
+            System.exit(exit);
+        } catch (Exception e) {
+            Throwable t = e;
+            while (t.getCause() != null && t.getCause() != t) {
+                t = t.getCause();
+            }
+
+            if (isDebug()) {
+                t.printStackTrace();
+            }
+            System.exit(1);
+        }
+    }
+
+    private static boolean isDebug() {
+        return System.getProperty("warbler.debug") != null;
+    }
+}

data/ext/WarMain.java

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2010-2011 Engine Yard, Inc.
+ * Copyright (c) 2007-2009 Sun Microsystems, Inc.
+ * This source code is available under the MIT license.
+ * 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.File;
+import java.io.FileOutputStream;
+import java.util.Arrays;
+
+public class WarMain implements Runnable {
+    public static final String MAIN = "/" + WarMain.class.getName().replace('.', '/') + ".class";
+    public static final String WINSTONE_JAR = "/WEB-INF/winstone.jar";
+
+    private String[] args;
+    private String path, warfile;
+    private boolean debug;
+    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();
+        this.webroot = File.createTempFile("winstone", "webroot");
+        this.webroot.delete();
+        this.webroot.mkdirs();
+        this.webroot = new File(this.webroot, new File(warfile).getName());
+        Runtime.getRuntime().addShutdownHook(new Thread(this));
+    }
+
+    private URL extractWinstone() throws Exception {
+        InputStream jarStream = new URL("jar:" + path.replace(MAIN, WINSTONE_JAR)).openStream();
+        File jarFile = File.createTempFile("winstone", ".jar");
+        jarFile.deleteOnExit();
+        FileOutputStream outStream = new FileOutputStream(jarFile);
+        try {
+            byte[] buf = new byte[4096];
+            int bytesRead = 0;
+            while ((bytesRead = jarStream.read(buf)) != -1) {
+                outStream.write(buf, 0, bytesRead);
+            }
+        } finally {
+            jarStream.close();
+            outStream.close();
+        }
+        debug("winstone.jar extracted to " + jarFile.getPath());
+        return jarFile.toURI().toURL();
+    }
+
+    private void launchWinstone(URL jar) throws Exception {
+        URLClassLoader loader = new URLClassLoader(new URL[] {jar});
+        Class klass = Class.forName("winstone.Launcher", true, loader);
+        Method main = klass.getDeclaredMethod("main", new Class[] {String[].class});
+        String[] newargs = new String[args.length + 3];
+        newargs[0] = "--warfile=" + warfile;
+        newargs[1] = "--webroot=" + webroot;
+        newargs[2] = "--directoryListings=false";
+        System.arraycopy(args, 0, newargs, 3, args.length);
+        debug("invoking Winstone with: " + Arrays.deepToString(newargs));
+        main.invoke(null, new Object[] {newargs});
+    }
+
+    private void start() throws Exception {
+        URL u = extractWinstone();
+        launchWinstone(u);
+    }
+
+    private void debug(String msg) {
+        if (debug) {
+            System.out.println(msg);
+        }
+    }
+
+    private void delete(File f) {
+        if (f.isDirectory()) {
+            File[] children = f.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                delete(children[i]);
+            }
+        }
+        f.delete();
+    }
+
+    public void run() {
+        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);
+        }
+    }
+
+    private static boolean isDebug() {
+        return System.getProperty("warbler.debug") != null;
+    }
+}
+

data/ext/WarblerJar.java

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2010-2011 Engine Yard, Inc.
+ * Copyright (c) 2007-2009 Sun Microsystems, Inc.
+ * This source code is available under the MIT license.
+ * See the file LICENSE.txt for details.
+ */
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.JRubyFile;
+
+public class WarblerJar {
+    public static void create(Ruby runtime) {
+        RubyModule task = runtime.getClassFromPath("Warbler::Jar");
+        task.defineAnnotatedMethods(WarblerJar.class);
+    }
+
+    @JRubyMethod
+    public static IRubyObject create_jar(ThreadContext context, IRubyObject recv, IRubyObject jar_path, IRubyObject entries) {
+        final Ruby runtime = recv.getRuntime();
+
+        if (!(entries instanceof RubyHash)) {
+            throw runtime.newArgumentError("expected a hash for the second argument");
+        }
+
+        RubyHash hash = (RubyHash) entries;
+        try {
+            FileOutputStream file = newFile(jar_path);
+            try {
+                ZipOutputStream zip = new ZipOutputStream(file);
+                addEntries(context, zip, hash);
+                zip.finish();
+            } finally {
+                close(file);
+            }
+        } catch (IOException e) {
+            if (runtime.isDebug()) {
+                e.printStackTrace();
+            }
+            throw runtime.newIOErrorFromException(e);
+        }
+
+        return runtime.getNil();
+    }
+
+    @JRubyMethod
+    public static IRubyObject entry_in_jar(ThreadContext context, IRubyObject recv, IRubyObject jar_path, IRubyObject entry) {
+        final Ruby runtime = recv.getRuntime();
+        try {
+            InputStream entryStream = getStream(jar_path.convertToString().getUnicodeValue(),
+                                                entry.convertToString().getUnicodeValue());
+            try {
+                byte[] buf = new byte[16384];
+                ByteList blist = new ByteList();
+                int bytesRead = -1;
+                while ((bytesRead = entryStream.read(buf)) != -1) {
+                    blist.append(buf, 0, bytesRead);
+                }
+                IRubyObject stringio = runtime.getModule("StringIO");
+                return stringio.callMethod(context, "new", runtime.newString(blist));
+            } finally {
+                close(entryStream);
+            }
+        } catch (IOException e) {
+            if (runtime.isDebug()) {
+                e.printStackTrace();
+            }
+            throw runtime.newIOErrorFromException(e);
+        }
+    }
+
+    private static void addEntries(ThreadContext context, ZipOutputStream zip, RubyHash entries) throws IOException {
+        RubyArray keys = entries.keys().sort(context, Block.NULL_BLOCK);
+        for (int i = 0; i < keys.getLength(); i++) {
+            IRubyObject key = keys.entry(i);
+            IRubyObject value = entries.op_aref(context, key);
+            addEntry(context, zip, key.convertToString().getUnicodeValue(), value);
+        }
+    }
+
+    private static void addEntry(ThreadContext context, ZipOutputStream zip, String entryName, IRubyObject value) throws IOException {
+        if (value.respondsTo("read")) {
+            RubyString str = (RubyString) value.callMethod(context, "read").checkStringType();
+            byte[] contents = str.getByteList().getUnsafeBytes();
+            zip.putNextEntry(new ZipEntry(entryName));
+            zip.write(contents);
+        } else {
+            File f;
+            if (value.isNil() || (f = getFile(value)).isDirectory()) {
+                zip.putNextEntry(new ZipEntry(entryName + "/"));
+            } else {
+                String path = f.getPath();
+                if (!f.exists()) {
+                    path = value.convertToString().getUnicodeValue();
+                }
+
+                InputStream inFile = getStream(path, null);
+                try {
+                    zip.putNextEntry(new ZipEntry(entryName));
+                    byte[] buf = new byte[16384];
+                    int bytesRead = -1;
+                    while ((bytesRead = inFile.read(buf)) != -1) {
+                        zip.write(buf, 0, bytesRead);
+                    }
+                } finally {
+                    close(inFile);
+                }
+            }
+        }
+    }
+
+    private static FileOutputStream newFile(IRubyObject jar_path) throws IOException {
+        return new FileOutputStream(getFile(jar_path));
+    }
+
+    private static File getFile(IRubyObject path) {
+        return JRubyFile.create(path.getRuntime().getCurrentDirectory(),
+                                path.convertToString().getUnicodeValue());
+    }
+
+    private static void close(Closeable c) {
+        try {
+            c.close();
+        } catch (Exception e) {
+        }
+    }
+
+    private static Pattern PROTOCOL = Pattern.compile("^[a-z][a-z0-9]+:");
+
+    private static InputStream getStream(String jar, String entry) throws IOException {
+        Matcher m = PROTOCOL.matcher(jar);
+        while (m.find()) {
+            jar = jar.substring(m.end());
+            m = PROTOCOL.matcher(jar);
+        }
+
+        String[] path = jar.split("!/");
+        InputStream stream = new FileInputStream(path[0]);
+        for (int i = 1; i < path.length; i++) {
+            stream = entryInJar(stream, path[i]);
+        }
+
+        if (entry == null) {
+            return stream;
+        }
+
+        return entryInJar(stream, entry);
+    }
+
+    private static InputStream entryInJar(InputStream jar, String entry) throws IOException {
+        ZipInputStream jstream = new ZipInputStream(jar);
+        ZipEntry zentry = null;
+        while ((zentry = jstream.getNextEntry()) != null) {
+            if (zentry.getName().equals(entry)) {
+                return jstream;
+            }
+            jstream.closeEntry();
+        }
+        throw new FileNotFoundException("entry '" + entry + "' not found in " + jar);
+    }
+}