buildr 0.16.0 → 0.18.0

data/lib/java/java.rb

@@ -1,7 +1,10 @@
+require 'stringio'
+
 module Buildr
   module Java
 
     JAVA_OPTIONS = [ :verbose, :noop, :cp, :classpath, :name, :java_args ]
+    JUNIT_REQUIRES = [ "junit:junit:jar:3.8.1", "jmock:jmock:jar:1.1.0" ]
 
     def self.java(*args)
       options = Hash === args.last ? args.pop : {}
@@ -44,6 +47,19 @@ module Buildr
       end
     end
 
+    # Gets the version of the java VM
+    def self.version()
+      @version ||= `java -version 2>&1`.scan(/java version "(.*)"/)[0][0]
+    end
+
+    def self.tools()
+      unless @tools
+        tools = File.join(ENV['JAVA_HOME'], "lib", "tools.jar")
+        @tools = File.exist?(tools) ? tools : []
+      end
+      @tools
+    end
+
     class AptTask < Rake::FileTask
 
       def initialize(*args)
@@ -94,9 +110,27 @@ module Buildr
       end
     end
 
+    def self.junit(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, :verbose, :noop, :cp, :classpath, :sourcepath, :output, :javac_args, :name
+
+      classpath = classpath_from(options) + junit_artifacts
+      tests = args.flatten
+      failed = tests.inject([]) do |failed, test|
+        begin
+          java "junit.textui.TestRunner", test, :classpath=>classpath, :name=>"tests in #{test}"
+          failed
+        rescue
+          failed << test
+        end
+      end
+      [ tests - failed, failed ]
+    end
+
   protected
 
-    def self.path_to_bin(name)
+    def self.path_to_bin(name = "java")
       ENV["JAVA_HOME"] ? File.join(ENV["JAVA_HOME"], "bin", name) : name
     end
 
@@ -105,6 +139,10 @@ module Buildr
       artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
     end
 
+    def self.junit_artifacts()
+      @junit_artifacts ||= artifacts(JUNIT_REQUIRES).each { |task| task.invoke }
+    end
+
   end
 
   def java(*args)

data/lib/java/jetty.rb

@@ -0,0 +1,123 @@
+require 'net/http'
+
+# Monkeypatching: forcing FileUtils to ignore .svn files when 
+# copying files around. We may want to implement our own deep
+# copy instead of hacking FileUtils in the future, but the cases
+# where you effectively want to copy .svn files are very, very
+# rare.
+module FileUtils
+  class Entry_
+    alias original_cp copy
+    def copy(dest)
+      unless path['.svn']
+        original_cp(dest)
+      end
+    end
+  end
+end
+
+module Buildr
+
+  module Jetty
+
+    VERSION = "6.1.1"
+
+    REQUIRES = [ "org.mortbay.jetty:jetty:jar:#{VERSION}",
+      "org.mortbay.jetty:jetty-util:jar:#{VERSION}",
+      "org.mortbay.jetty:servlet-api-2.5:jar:#{VERSION}",
+      "log4j:log4j:jar:1.2.13",
+      "commons-logging:commons-logging:jar:1.1"
+    ]
+
+    OPTIONS = [ :classpath, :war_path, :context_path, :noop, :base_url, :process_alias ]
+
+    # Bouncing a webapp deployed in the Jetty web server. Just does a post
+    # to a buildr specific handler. If there's nothing on the other side,
+    # a new Jetty instance is spawned.
+    def self.bounce(options)
+      fu_check_options options, *OPTIONS
+      options[:classpath] ||= []
+      
+      begin
+        puts "Bouncing webapp #{options[:war_path]}" if verbose
+        res = jetty_call('/bounce', :post, options)
+        puts "done." if verbose
+      rescue Errno::ECONNREFUSED => e
+        puts "Web server not found, spawning it."
+        runtool options.merge(:class=>"JettyWrapper",
+                              :args=>[ options[:war_path], options[:context_path] ],
+                              :classpath=>options[:classpath] + ['../buildr/lib/java/jetty'])
+      end
+
+      case res
+      when Net::HTTPNotFound
+        fail "A web server seems to be already running without Buildr deployment hooks."
+      when Net::HTTPInternalServerError
+        fail "Server error occured when redeploying the WAR, see the web server logs."
+      end
+    end
+
+    # Sends an http request to the buildr handler deployed in Jetty.
+    def self.jetty_call(rel_url, get_post, options)
+      base_url = URI.parse((options[:base_url] || 'http://localhost:8080/buildr') + rel_url)
+      req = get_post == :post ? Net::HTTP::Post.new(base_url.path) : Net::HTTP::Get.new(base_url.path)
+      res = Net::HTTP.start(base_url.host, base_url.port) {|http| http.request(req) }
+    end
+
+  protected
+
+    def self.runtool(options)
+      classpath = REQUIRES + (options[:classpath] || []).collect | (options[:cp] || []).collect
+      classpath = artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+      cmd_args = ["-cp", classpath.join(File::PATH_SEPARATOR)]
+      cmd_args << options[:class]
+      cmd_args += options[:args]
+      unless options[:noop]
+        if fork.nil?
+          STDOUT.reopen File.new("stdout.log", "w")
+          STDERR.reopen File.new("stderr.log", "w")
+          exec ([Java.path_to_bin("java")] + cmd_args).join(' ')
+        end
+      end
+    end
+    
+    class JettyTask < Rake::Task
+      def initialize(*args)
+        super
+        enhance do |task|
+          Jetty.bounce task.options
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+    end
+  end
+
+  class Project
+    def webserve(&block)
+      task "jetty:shutdown" do
+        begin
+          res = Jetty.jetty_call('/stop', :put, @webserve_task.options)
+          puts "Response #{res}" if verbose
+        rescue Errno::ECONNREFUSED
+            puts "Jetty server couldn't be contacted, nothing done."
+        rescue EOFError
+            puts "Shutdown successful."
+        rescue Exception => e
+            puts "Unexpected error: #{e.class}"
+        end
+      end
+      returning(@webserve_task ||= Jetty::JettyTask.define_task("jetty:bounce"=>package(:war))) do |task|
+        task.enhance &block if block
+      end
+    end
+  end
+  
+end

data/lib/java/jetty/JettyWrapper.java

@@ -0,0 +1,107 @@
+import org.mortbay.jetty.Server;
+import org.mortbay.jetty.Request;
+import org.mortbay.jetty.Handler;
+import org.mortbay.jetty.handler.AbstractHandler;
+import org.mortbay.jetty.handler.ContextHandler;
+import org.mortbay.jetty.handler.ContextHandlerCollection;
+import org.mortbay.jetty.webapp.WebAppContext;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.ServletException;
+import java.io.IOException;
+
+/**
+ * @author Matthieu Riou <mriou at apache dot org>
+ */
+public class JettyWrapper {
+
+    private Server _server;
+    private WebAppContext _webAppHandler;
+    private ContextHandlerCollection _handlerColl;
+    private String _webAppDir;
+    private String _contextPath;
+
+    public JettyWrapper(String webAppDir, String contextPath) {
+        _server = new Server(8080);
+        _webAppDir = webAppDir;
+        _contextPath = contextPath;
+
+        // Adding handler for the war to deploy
+        _webAppHandler = new WebAppContext(_webAppDir, _contextPath);
+        _webAppHandler.setConfigurationClasses(new String[] {
+                "org.mortbay.jetty.webapp.WebInfConfiguration",
+                "org.mortbay.jetty.webapp.WebXmlConfiguration"});
+
+        // Adding the buildr handler to control our server lifecycle
+        ContextHandler context = new ContextHandler();
+        context.setContextPath("/buildr");
+        Handler handler = new BuildrHandler();
+        context.setHandler(handler);
+
+        _handlerColl = new ContextHandlerCollection();
+        _handlerColl.setHandlers(new Handler[] {_webAppHandler, context});
+
+        _server.addHandler(_handlerColl);
+    }
+
+    public void start() {
+        try {
+            _server.start();
+            _server.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        if (args.length != 2) {
+            System.out.println("Please provide the webapp directory and the context path.");
+        }
+        String webAppDir = args[0];
+        String contextPath = args[1];
+        JettyWrapper jetwrap = new JettyWrapper(webAppDir, contextPath);
+        jetwrap.start();
+    }
+
+    private class BuildrHandler extends AbstractHandler {
+
+        public void handle(String string, HttpServletRequest request,
+                           HttpServletResponse response, int i) throws IOException, ServletException {
+            response.setContentType("text/html");
+            if (request.getPathInfo().equals("/bounce")) {
+                try {
+                    _webAppHandler.stop();
+                    _handlerColl.removeHandler(_webAppHandler);
+                    _webAppHandler = new WebAppContext(_webAppDir, _contextPath);
+                    _webAppHandler.setConfigurationClasses(new String[] {
+                            "org.mortbay.jetty.webapp.WebInfConfiguration",
+                            "org.mortbay.jetty.webapp.WebXmlConfiguration"});
+                    _handlerColl.addHandler(_webAppHandler);
+                    _webAppHandler.start();
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+                    ((Request)request).setHandled(true);
+                    return;
+                }
+            } else if (request.getPathInfo().equals("/stop")) {
+                try {
+                    _server.stop();
+                    _server.destroy();
+                    // Brute force
+                    System.exit(0);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            } else if (request.getPathInfo().equals("/war")) {
+		response.getWriter().println(_webAppHandler.getTempDirectory());
+		((Request)request).setHandled(true);
+		return;
+	    }
+            response.getWriter().println("OK " + request.getPathInfo());
+            ((Request)request).setHandled(true);
+        }
+
+    }
+}

data/lib/java/openjpa.rb

@@ -36,16 +36,14 @@ module Buildr
   protected
 
     def self.runtool(options)
-      classpath = REQUIRES + (options[:classpath] || []).collect | (options[:cp] || []).collect
-      classpath = artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
-      cmd_args = ["-cp", classpath.join(File::PATH_SEPARATOR)]
-      cmd_args << options[:class]
-      cmd_args += options[:args].select { |n, v| v }.map { |n, v| [ n, v ] }.flatten
-      cmd_args << { :verbose=>options[:verbose] }
-      unless options[:noop]
-        verbose { puts "Running OpenJPA #{options[:name]}" }
-        sh(Java.path_to_bin("java"), *cmd_args) { |ok, res| fail "Failed to execute OpenJPA #{options[:name]}, see errors above" unless ok }
-      end
+      args = [options[:class]] + options[:args].select { |n, v| v }.map { |n, v| [ n, v ] }.flatten
+      args << { :classpath=>requires + (options[:classpath] || []),
+                :name=>"OpenJPA #{options[:name]}", :verbose=>options[:verbose] }
+      java *args
+    end
+
+    def self.requires()
+      @required ||= artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
     end
 
   end

data/lib/java/packaging.rb

@@ -3,10 +3,11 @@ module Buildr
 
     module Packaging
 
-      MANIFEST_HEADER = "Manifest-Version: 1.0\nCreated-By: Ruby Build System"
+      MANIFEST_HEADER = "Manifest-Version: 1.0\nCreated-By: Buildr\n"
 
       class JarTask < ZipTask
         attr_accessor :manifest
+        attr_accessor :meta_inf
 
         def initialize(*args)
           super
@@ -16,6 +17,8 @@ module Buildr
         def []=(key, value)
           if key.to_sym == :manifest
             self.manifest = value
+          elsif key.to_sym == :meta_inf
+            self.meta_inf = value
           else
             super key, value
           end
@@ -25,23 +28,25 @@ module Buildr
       protected
 
         def create(zip)
-          if manifest
-            zip.mkdir "META-INF"
+          zip.mkdir "META-INF"
+          meta_inf.each { |file| zip.add "META-INF/#{File.basename(file)}", file } if meta_inf
+          unless manifest == false
             zip.file.open("META-INF/MANIFEST.MF", "w") do |output|
               output.write MANIFEST_HEADER
-              case manifest
-              when Hash
-                output.write manifest.map { |pair| pair.join(": ") }.join("\n")
-              when Array
-                manifest.each do |section|
-                  output.write "\n"
-                  output.write section.map { |pair| pair.join(": ") }.join("\n")
+              if manifest
+                case manifest
+                when Hash
+                  output.write manifest.map { |pair| pair.join(": ") }.sort.join("\n")
+                when Array
+                  manifest.each do |section|
+                    output.write "\n"
+                    output.write section.map { |pair| pair.join(": ") }.sort.join("\n")
+                  end
+                when Proc, Method
+                  output.write manifest.call 
+                when String
+                  output.write File.read(manifest)
                 end
-              when Proc, Method
-                output.write manifest.call 
-              when String
-                output.write File.read(manifest)
-              when true # Default behavior
               end
               output.write "\n"
             end
@@ -56,7 +61,7 @@ module Buildr
         def []=(key, value)
           case key.to_sym
           when :libs
-            self.include value, :path=>"WEB-INF/lib"
+            self.include artifacts(value), :path=>"WEB-INF/lib"
           when :classes
             self.include value, :path=>"WEB-INF/classes"
           else
@@ -79,13 +84,22 @@ module Buildr
     Packaging::JarTask.define_task(file)
   end
 
-
   class Project
 
     # Group used for packaging. Inherited from parent project.
     inherited_attr :group
     # Version used for packaging. Inherited from parent project.
     inherited_attr :version
+    # Manifest used for packaging. Inherited from parent project.
+    inherited_attr :manifest do |project|
+      manifest = { "Build-By"=>ENV['USER'], "Build-Jdk"=>Java.version }
+      manifest["Implementation-Version"] = project.version if project.version
+      manifest
+    end
+    # Files to always include in the package META-INF directory.
+    inherited_attr :meta_inf do |project|
+      meta_inf = ["DISCLAIMER", "LICENSE", "NOTICE"].map { |f| path_to(f) if File.exist?(path_to(f)) }.compact
+    end
 
     # The project ID is the project name, and for a sub-project the
     # parent project ID followed by the project name, separated with a
@@ -97,7 +111,7 @@ module Buildr
 
     def package(*args)
       if Hash === args.last
-        options = args.pop.clone
+        options = args.pop.dup
       else
         options = {}
       end
@@ -117,14 +131,14 @@ module Buildr
         fail("Do not know how to create a package of type #{options[:type]}")
       package = packager.call(file, options) or fail("Do not know how to create a package of type #{options[:type]}")
 
-      task("package").enhance [package]
-      package.enhance [task("build")]
+      task "package"=>package
+      package.enhance [ task("build")]
 
-      task "install"=>[
-        file_create(File.dirname(repositories.locate(package))) { |task| mkpath task.name, :verbose=>false },
-        file(repositories.locate(package)=>package) { |task| cp package.name, task.name },
-        package.pom
-      ]
+      task "install"=>(file(repositories.locate(package)=>package) { |task|
+        mkpath File.dirname(task.name), :verbose=>false
+        cp package.name, task.name
+      })
+      task "install"=>package.pom
 
       task "uninstall" do |task|
         verbose(Rake.application.options.trace) do
@@ -147,30 +161,49 @@ module Buildr
   protected
 
     def package_as_jar(file, options)
+      unless Rake::Task.task_defined?(file)
+        returning(Java::Packaging::JarTask.define_task(file)) do |task|
+          package_extend task, options
+          task.enhance [path_to(:java_target_dir)]
+          task.include path_to(:java_target_dir, "*")
+          task.manifest = manifest.merge("Implementation-Title"=>self.comment)
+          task.meta_inf = meta_inf
+        end
+      end
       returning(Java::Packaging::JarTask.define_task(file)) do |task|
-        package_extend task, options
-        task.include path_to(:java_target_dir, "*")
         task.include options[:include] if options[:include]
         task.manifest = options[:manifest] if options[:manifest]
       end
     end
 
     def package_as_war(file, options)
+      unless Rake::Task.task_defined?(file)
+        returning(Java::Packaging::WarTask.define_task(file)) do |task|
+          package_extend task, options
+          task.include path_to(:webapp_src_dir, "*")
+          task.with :classes=>path_to(:java_target_dir, "**")
+          task.manifest = manifest.merge("Implementation-Title"=>self.comment)
+          task.meta_inf = meta_inf
+        end
+      end
       # Add anything we find in webapp sources directory.
       returning(Java::Packaging::WarTask.define_task(file)) do |task|
-        package_extend task, options
-        task.include path_to(:webapp_src_dir, "*")
         task.include options[:include] if options[:include]
         # Add libraries in WEB-INF lib, and classes in WEB-INF classes
         task.with :libs=>options[:libs].collect if options[:libs]
-        task.with :classes=>(options[:classes] || path_to(:java_target_dir, "**")) unless options[:classes] == false
+        task.with :classes=>options[:classes] if options[:classes]
+        task.manifest = options[:manifest] if options[:manifest]
       end
     end
 
     def package_as_zip(file, options)
+      unless Rake::Task.task_defined?(file)
+        returning(ZipTask.define_task(file)) do |task|
+          package_extend task, options
+          task.include path_to(:java_target_dir, "*")
+        end
+      end
       returning(ZipTask.define_task(file)) do |task|
-        package_extend task, options
-        task.include path_to(:java_target_dir, "*")
         task.include options[:include] if options[:include]
       end
     end