buildr 1.3.5-x86-mswin32

data/addon/buildr/nailgun.rb

@@ -0,0 +1,221 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'jruby'
+require 'rbconfig'
+require 'tmpdir'
+require 'buildr/drb'
+
+
+module Buildr
+  
+  # This addon is provided for fast interaction with a DRb BuildrServer (buildr/drb).
+  # 
+  # This module delegates task invocation to the BuildrServer, it only implements
+  # nailgun required logic (server/client).
+  #
+  # Usage:
+  #
+  #   buildr -r buildr/nailgun nailgun:start
+  # 
+  # Once the server has been started you can invoke tasks using the nailgun client
+  # installed on $JRUBY_HOME/tool/nailgun. It's recommended to add this path to 
+  # your PATH environment variable, so that the ng command is available at any dir.
+  #
+  #   ng build # invoke the build task
+  #
+  module Nailgun
+    extend self
+
+    VERSION = '0.7.1'
+    NAME = "nailgun-#{VERSION}"
+    URL = "http://downloads.sourceforge.net/nailgun/#{NAME}.zip"
+    ARTIFACT_SPEC = "com.martiansoftware:nailgun:jar:#{VERSION}"
+    PORT = DRbApplication::PORT + 2
+    ADDON_BIN = File.dirname(__FILE__)
+    
+    # Returns the path to JRUBY_HOME.
+    def jruby_home
+      ENV['JRUBY_HOME'] || Config::CONFIG['prefix']
+    end
+    
+    # Returns the path to NAILGUN_HOME.
+    def nailgun_home
+      ENV['NAILGUN_HOME'] || File.expand_path('tool/nailgun', jruby_home)
+    end
+
+    def tmp_path(*paths)
+      File.join(Dir.tmpdir, 'nailgun', *paths)
+    end
+
+    module Util
+      extend self
+
+      def add_to_sysloader(path)
+        sysloader = java.lang.ClassLoader.getSystemClassLoader
+        add_url_method = java.lang.Class.forName('java.net.URLClassLoader').
+          getDeclaredMethod('addURL', [java.net.URL.java_class].to_java(java.lang.Class))
+        add_url_method.setAccessible(true)
+        add_url_method.invoke(sysloader, [java.io.File.new(path).toURI.toURL].to_java(java.net.URL))
+      end
+
+      # invoke a java constructor
+      def ctor(on_class, *args)
+        parameters = []
+        classes = []
+        args.each do |obj|
+          case obj
+          when nil
+            classes.push(nil)
+            parameters.push(nil)
+          when Hash
+            vclass = obj.keys.first
+            value = obj[vclass]
+            classes.push(vclass.java_class)
+            parameters.push(value)
+          else
+            parameters.push obj
+            classes.push obj.class.java_class
+          end
+        end
+        on_class = [on_class.java_class].to_java(java.lang.Class)[0]
+        ctor = on_class.getDeclaredConstructor(classes.to_java(java.lang.Class))
+        ctor.setAccessible(true)
+        ctor.newInstance(parameters.to_java(java.lang.Object))
+      end
+
+    end # Util
+
+    module Client
+
+      def main(nail)
+        nail.out.println "Connected to #{nail.getNGServer}"
+
+        runtime = JRuby.runtime
+
+        stdout = Util.ctor(org.jruby.RubyIO, runtime, java.io.OutputStream => nail.out)
+        stderr = Util.ctor(org.jruby.RubyIO, runtime, java.io.OutputStream => nail.err)
+        stdin = Util.ctor(org.jruby.RubyIO, runtime, java.io.InputStream => nail.in)
+        
+        dir = nail.getWorkingDirectory
+        argv = [nail.command] + nail.args
+        
+        DRbApplication.remote_run :dir => dir, :argv => argv,
+                                  :in => stdin, :out => stdout, :err => stderr
+      rescue => e
+        nail.err.println e unless SystemExit === e
+        nail.exit 1
+      end
+      
+    end # Client
+
+    module Server
+      def initialize(host, port)
+        @host = host || "*"
+        @port = port
+        super(host, port)
+      end
+
+      def start
+        self.allow_nails_by_class_name = false
+        
+        NGClient::Main.nail = NGClient.new
+        self.default_nail_class = NGClient::Main
+        
+        @thread = java.lang.Thread.new(self)
+        @thread.setName(to_s)
+        @thread.start
+        
+        sleep 1 while getPort == 0
+        info "#{self} Started."
+      end
+      
+      def stop
+        @thread.kill
+      end
+
+      def to_s
+        version = "Buildr #{Buildr::VERSION} #{RUBY_PLATFORM[/java/] && '(JRuby '+JRUBY_VERSION+')'}"
+        self.class.name+'('+[version, @host, @port].join(', ')+')'
+      end
+    end # Server
+
+    namespace(:nailgun) do
+
+      dist_zip = Buildr.download(tmp_path(NAME + '.zip') => URL)
+      dist_dir = Buildr.unzip(tmp_path(NAME) => dist_zip)
+      
+      nailgun_jar = file(tmp_path(NAME, NAME, NAME + '.jar'))
+      nailgun_jar.enhance [dist_dir] unless File.exist?(nailgun_jar.to_s)
+
+      attr_reader :artifact
+      @artifact = Buildr.artifact(ARTIFACT_SPEC).from(nailgun_jar)
+      
+      compiled_bin = file(tmp_path(NAME, NAME, 'ng' + Config::CONFIG['EXEEXT']) => dist_dir.target) do |task|
+        unless task.to_s.pathmap('%x') == '.exe'
+          Dir.chdir(task.to_s.pathmap('%d')) do
+            info "Compiling #{task.to_s}"
+            system('make', task.to_s.pathmap('%f')) or
+              fail "Nailgun binary compilation failed."
+          end
+        end
+      end
+
+      attr_reader :installed_bin
+      @installed_bin = file(File.expand_path(compiled_bin.to_s.pathmap('%f'), nailgun_home) => compiled_bin) do |task|
+        mkpath task.to_s.pathmap('%d'), :verbose => false
+        cp compiled_bin.to_s, task.to_s, :verbose => false
+      end
+
+      task('drb-notice') do
+        info ''
+        info 'Running in JRuby, a nailgun server will be started so that'
+        info 'you can use your nailgun client to invoke buildr tasks: '
+        info ''
+        info '  '+Nailgun.installed_bin.to_s
+        info ''
+      end
+
+      task('drb' => ['drb-notice', 'start'])
+
+      desc 'Start the nailgun server'
+      task('start' => [installed_bin, 'setup']) do |task|
+        server = NGServer.new(nil, PORT)
+        server.start
+      end
+
+      task('setup' => artifact) do 
+        module Util
+          include Buildr::Util
+        end
+        
+        Util.add_to_sysloader artifact.to_s
+        Util.add_to_sysloader ADDON_BIN
+        
+        class NGClient
+          include org.apache.buildr.BuildrNail
+          include Client
+        end
+        
+        class NGServer < com.martiansoftware.nailgun.NGServer
+          include Server
+        end      
+      end
+      
+    end # ng_tasks
+      
+  end # module Nailgun
+end

data/addon/buildr/openjpa.rb

@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/java'
+
+
+module Buildr
+
+  # Provides OpenJPA bytecode enhancement and Mapping tool task. Require explicitly using <code>require "buildr/openjpa"</code>.
+  module OpenJPA
+
+    VERSION = "1.0.1"
+
+    REQUIRES = [ "org.apache.openjpa:openjpa:jar:#{VERSION}",
+      "commons-collections:commons-collections:jar:3.1",
+      "commons-dbcp:commons-dbcp:jar:1.2.1", 
+      "commons-lang:commons-lang:jar:2.1",
+      "commons-pool:commons-pool:jar:1.2",
+      "javax.persistence:persistence-api:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-j2ee-connector_1.5_spec:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-jta_1.0.1B_spec:jar:1.0",
+      "net.sourceforge.serp:serp:jar:1.11.0" ]
+
+    Java.classpath << REQUIRES
+
+    class << self
+
+      def enhance(options)
+        rake_check_options options, :classpath, :properties, :output
+        artifacts = Buildr.artifacts(options[:classpath]).each { |a| a.invoke }.map(&:to_s) + [options[:output].to_s]
+        properties = file(options[:properties]).tap { |task| task.invoke }.to_s
+
+        Buildr.ant "openjpa" do |ant|
+          ant.taskdef :name=>"enhancer", :classname=>"org.apache.openjpa.ant.PCEnhancerTask",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.enhancer :directory=>options[:output].to_s do
+            ant.config :propertiesFile=>properties
+            ant.classpath :path=>artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+      end
+
+      def mapping_tool(options)
+        rake_check_options options, :classpath, :properties, :sql, :action
+        artifacts = Buildr.artifacts(options[:classpath]).each{ |a| a.invoke }.map(&:to_s)
+        properties = file(options[:properties].to_s).tap { |task| task.invoke }.to_s
+
+        Buildr.ant("openjpa") do |ant|
+          ant.taskdef :name=>"mapping", :classname=>"org.apache.openjpa.jdbc.ant.MappingToolTask",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.mapping :schemaAction=>options[:action], :sqlFile=>options[:sql].to_s, :ignoreErrors=>"true" do
+            ant.config :propertiesFile=>properties
+            ant.classpath :path=>artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+      end
+
+    private
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+      end
+
+    end
+
+    def open_jpa_enhance(options = nil)
+      jpa_options = { :output=>compile.target, :classpath=>compile.dependencies,
+                      :properties=>path_to(:source, :main, :resources, 'META-INF/persistence.xml') }
+      OpenJPA.enhance jpa_options.merge(options || {})
+    end
+
+  end
+
+  class Project
+    include OpenJPA
+  end
+end

data/addon/buildr/org/apache/buildr/BuildrNail.java

@@ -0,0 +1,41 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership.  The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package org.apache.buildr;
+
+import com.martiansoftware.nailgun.NGContext;
+
+public interface BuildrNail {
+  
+  public void main(NGContext ctx);
+
+  public static class Main {
+     private static BuildrNail nail;
+     public static void  setNail(BuildrNail _nail) { nail = _nail; }
+     public static void nailMain(NGContext ctx) {
+       nail.main(ctx);
+     }
+  }
+
+}
+
+/* 
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * c-basic-offset: 2
+ * End:
+ */

data/addon/buildr/org/apache/buildr/JettyWrapper.java

@@ -0,0 +1,144 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership.  The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package org.apache.buildr;
+ 
+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 org.mortbay.jetty.webapp.WebAppClassLoader;
+
+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>
+ */
+public class JettyWrapper {
+
+    private Server _server;
+    private ContextHandlerCollection _handlerColl;
+
+    public JettyWrapper(int port) throws Exception {
+        _server = new Server(port);
+        // 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[] {context});
+
+        _server.addHandler(_handlerColl);
+        _server.start();
+    }
+
+/*
+    public void join() {
+        try {
+            _server.join();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+*/
+
+    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("/")) {
+                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"});
+                    context.setClassLoader(new WebAppClassLoader(context));
+                    
+                    _handlerColl.addHandler(context);
+                    context.start();
+                    _apps.put(path, context);
+                    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 {
+                    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);
+                    ((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();
+                }
+            }
+            response.getWriter().println("OK " + request.getPathInfo());
+            ((Request)request).setHandled(true);
+        }
+
+    }
+}