buildr 0.18.0 → 0.19.0

data/lib/java/jetty.rb

@@ -1,123 +1,234 @@
-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
+require "uri"
+require "net/http"
+require "core/project"
+require "java/artifact"
 
 module Buildr
 
-  module Jetty
+  # Provides a collection of tasks and methods for using Jetty, specifically as a server
+  # for testing your application.
+  #
+  # Build files should always start Jetty by invoking the #use task, typically as
+  # a prerequisite. This task will start Jetty once during the build, and shut it down
+  # when the build completes.
+  #
+  # If you want to keep Jetty running across builds, and look at error messages, you can
+  # start Jetty in a separate console with:
+  #   rake jetty:start
+  # To stop this instance of Jetty, simply kill the process (Ctrl-C) or run:
+  #   rake jetty:stop
+  #
+  # If you start Jetty separately from the build, the #use task will connect to that
+  # existing server. Since you are using Jetty across several builds, you will want to
+  # cleanup any mess created by each build. You can use the #setup and #teardown tasks,
+  # which are called when Jetty is first used in the build, and when the build ends.
+  class Jetty
+
+    class << self
 
-    VERSION = "6.1.1"
+      # :call-seq:
+      #   instance() => Jetty
+      #
+      # Returns an instance of Jetty.
+      def instance()
+        @instance ||= Jetty.new
+      end
 
-    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"
-    ]
+    end
 
-    OPTIONS = [ :classpath, :war_path, :context_path, :noop, :base_url, :process_alias ]
+    # Artifacts required to run Jetty.
+    REQUIRES = [ "org.mortbay.jetty:jetty:jar:6.1.1", "org.mortbay.jetty:jetty-util:jar:6.1.1",
+                 "org.mortbay.jetty:server-api-2.5:jar:6.1.1", "log4j:log4j:jar:1.2.13",
+                 "commons-logging:commons-logging:jar:1.1" ]
 
-    # 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
+    # Default URL for Jetty.
+    URL = "http://localhost:8080"
 
-      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."
+    def initialize() #:nodoc:
+      @url = URL
+      namespace "jetty" do
+        @setup = task("setup")
+        @teardown = task("teardown")
+        @use = task("use") { fire }
       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) }
+    # The URL for the Jetty server. Leave as is if you want to use the default server
+    # (http://localhost:8080).
+    attr_accessor :url
+
+    # :call-seq:
+    #    start(pipe?)
+    #
+    # Starts Jetty. This method does not return, it keeps the thread running until
+    # Jetty is stopped. If you want to run Jetty parallel with other tasks in the build,
+    # invoke the #use task instead.
+    def start(pipe = nil)
+      begin
+        Java.rjb.classpath += REQUIRES
+        Java.rjb.classpath << File.join(__DIR__, "jetty")
+        Java.rjb do
+          port = URI.parse(url).port
+          puts "Starting Jetty at http://localhost:#{port}"
+          jetty = Rjb::import("JettyWrapper").new(port)
+          if pipe
+            pipe.puts "Started"
+            pipe.close
+          end
+          sleep # Forever
+        end
+      rescue Interrupt # Stopped from console
+      end
+      exit! # No at_exit
     end
 
-  protected
+    # :call-seq:
+    #    stop()
+    #
+    # Stops Jetty. Stops a server running in a separate process.
+    def stop()
+      uri = URI.parse(url)
+      begin
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request_post "/buildr/stop", ""
+        end
+      rescue Errno::ECONNREFUSED
+        # Expected if Jetty server not running.
+      rescue EOFError
+        # We get EOFError because Jetty is brutally killed.
+      end
+      puts "Jetty server stopped"
+    end
 
-    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(' ')
+    # :call-seq:
+    #   running?() => boolean
+    #
+    # Returns true if it finds a running Jetty server that supports the Buildr
+    # requests for deploying, stopping, etc.
+    def running?()
+      uri = URI.parse(url)
+      begin
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          response = http.request_get("/buildr/")
+          response.is_a?(Net::HTTPSuccess) && response.body =~ /Alive/
         end
+      rescue Errno::ECONNREFUSED
+        false
       end
     end
-    
-    class JettyTask < Rake::Task
-      def initialize(*args)
-        super
-        enhance do |task|
-          Jetty.bounce task.options
+
+    # :call-seq:
+    #   deploy(url, webapp) => path
+    #
+    # Deploy a WAR in the specified URL.
+    def deploy(url, webapp)
+      use.invoke
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request_post("/buildr/deploy", "webapp=#{webapp}&path=#{uri.path}")
+        if Net::HTTPOK === response && response.body =~ /Deployed/
+          path = response.body.split[1]
+          puts "Deployed #{webapp}, context path #{uri.path}" if Rake.application.options.trace
+          path
+        else
+          fail "Deployment failed: #{response}"
         end
       end
+    end
 
-      def options()
-        @options ||= {}
+    # :call-seq:
+    #   undeploy(url) => boolean
+    #
+    # Undeploys a WAR from the specified URL.
+    def undeploy(url)
+      use.invoke
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request_post("/buildr/undeploy", "path=#{uri.path}")
+        if Net::HTTPOK === response && response.body =~ /Undeployed/
+          true
+        else
+          fail "Deployment failed: #{response}"
+        end
       end
+    end
+
+    # :call-seq:
+    #   setup(*prereqs) => task
+    #   setup(*prereqs) { |task| .. } => task
+    #
+    # This task executes when Jetty is first used in the build. You can use it to
+    # deploy artifacts into Jetty.
+    def setup(*prereqs, &block)
+      @setup.enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #   teardown(*prereqs) => task
+    #   teardown(*prereqs) { |task| .. } => task
+    #
+    # This task executes when the build is done. You can use it to undeploy artifacts
+    # previously deployed into Jetty.
+    def teardown(*prereqs, &block)
+      @teardown.enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #   use(*prereqs) => task
+    #   use(*prereqs) { |task| .. } => task
+    #
+    # If you intend to use Jetty, invoke this task. It will start a new instance of
+    # Jetty and close it when the build is done. However, if you already have a server
+    # running in the background (e.g. jetty:start), it will use that server and will
+    # not close it down.
+    def use(*prereqs, &block)
+      @use.enhance prereqs, &block
+    end
+
+  protected
 
-      def using(options)
-        self.options.merge!(options)
-        self
+    # If you want to start Jetty inside the build, call this method instead of #start.
+    # It will spawn a separate process that will run Jetty, and will stop Jetty when
+    # the build ends. However, if you already started Jetty from the console (with
+    # take jetty:start), it will use the existing instance without shutting it down.
+    def fire()
+      unless running?
+        reader, writer = IO.pipe
+        if pid = fork
+          # Wait for Jetty to fire up before doing anything else.
+          if reader.gets == "Started"
+            puts "Jetty started"
+            reader.close
+          end
+          at_exit { stop }
+        else
+          start writer
+        end
       end
+      @setup.invoke
+      at_exit { @teardown.invoke }
     end
+
+  end
+
+  namespace "jetty" do
+    desc "Start an instance of Jetty running in the background"
+    task("start") { Jetty.instance.start }
+    desc "Stop an instance of Jetty running in the background"
+    task("stop") { Jetty.instance.stop }
   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
+
+    # :call-seq:
+    #   jetty() => Jetty
+    #
+    # Returns a Jetty object. You can use this to discover the Jetty#use task,
+    # configure the Jetty#setup and Jetty#teardown tasks, deploy and undeploy to Jetty.
+    def jetty()
+      @jetty ||= Jetty.instance
     end
+
   end
   
 end

data/lib/java/jetty/JettyWrapper.java

@@ -10,6 +10,7 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.ServletException;
 import java.io.IOException;
+import java.util.HashMap;
 
 /**
  * @author Matthieu Riou <mriou at apache dot org>
@@ -22,16 +23,16 @@ public class JettyWrapper {
     private String _webAppDir;
     private String _contextPath;
 
-    public JettyWrapper(String webAppDir, String contextPath) {
-        _server = new Server(8080);
-        _webAppDir = webAppDir;
-        _contextPath = contextPath;
+    public JettyWrapper(int port/*String webAppDir, String contextPath*/) throws Exception {
+        _server = new Server(port);
+        //_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"});
+        //_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();
@@ -40,20 +41,21 @@ public class JettyWrapper {
         context.setHandler(handler);
 
         _handlerColl = new ContextHandlerCollection();
-        _handlerColl.setHandlers(new Handler[] {_webAppHandler, context});
+        _handlerColl.setHandlers(new Handler[] {/*_webAppHandler,*/ context});
 
         _server.addHandler(_handlerColl);
+        _server.start();
     }
 
     public void start() {
         try {
-            _server.start();
+            //_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.");
@@ -63,22 +65,69 @@ public class JettyWrapper {
         JettyWrapper jetwrap = new JettyWrapper(webAppDir, contextPath);
         jetwrap.start();
     }
+*/
 
     private class BuildrHandler extends AbstractHandler {
 
+        private HashMap _apps = new HashMap();
+
         public void handle(String string, HttpServletRequest request,
                            HttpServletResponse response, int i) throws IOException, ServletException {
             response.setContentType("text/html");
-            if (request.getPathInfo().equals("/bounce")) {
+            if (request.getPathInfo().equals("/")) {
+                response.getWriter().println("Alive");
+                ((Request)request).setHandled(true);
+                return;
+            } else if (request.getPathInfo().equals("/deploy")) {
+                try {
+                    String webapp = request.getParameter("webapp");
+                    String path = request.getParameter("path");
+                    System.out.println("Deploying " + webapp + " in " + path);
+                    WebAppContext context;
+            
+                    context = (WebAppContext) _apps.get(path);
+                    if (context != null) {
+                        context.stop();
+                        _handlerColl.removeHandler(context);
+                        _apps.remove(path);
+                    }
+
+                    context = new WebAppContext(webapp, path);
+                    context.setConfigurationClasses(new String[] {
+                        "org.mortbay.jetty.webapp.WebInfConfiguration",
+                        "org.mortbay.jetty.webapp.WebXmlConfiguration"});
+                    _handlerColl.addHandler(context);
+                    context.start();
+                    _apps.put(path, context);
+                    //_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();
+                    response.getWriter().println("Deployed");
+                    response.getWriter().println(context.getTempDirectory());
+                    ((Request)request).setHandled(true);
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+                    ((Request)request).setHandled(true);
+                    return;
+                }
+            } else if (request.getPathInfo().equals("/undeploy")) {
                 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();
+                    String path = request.getParameter("path");
+                    WebAppContext context = (WebAppContext) _apps.get(path);
+                    if (context != null) {
+                        System.out.println("Undeploying app at " + path);
+                        context.stop();
+                        _handlerColl.removeHandler(context);
+                        _apps.remove(path);
+                    }
+                    response.getWriter().println("Undeployed");
+                    ((Request)request).setHandled(true);
                 } catch (Throwable e) {
                     e.printStackTrace();
                     response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);