buildr 1.3.3-java → 1.3.4-java

data/addon/buildr/nailgun.rb

@@ -13,103 +13,39 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'benchmark'
+
 require 'jruby'
-require 'monitor'
-require 'ostruct'
 require 'rbconfig'
-require 'thread'
-require 'buildr/core/application_cli'
+require 'tmpdir'
+require 'buildr/drb'
 
-module Buildr #:nodoc:
 
+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
-    
-    attr_reader :ng
-    @ng ||= OpenStruct.new
 
     VERSION = '0.7.1'
     NAME = "nailgun-#{VERSION}"
     URL = "http://downloads.sourceforge.net/nailgun/#{NAME}.zip"
     ARTIFACT_SPEC = "com.martiansoftware:nailgun:jar:#{VERSION}"
-
-    # Paths used to initialize a buildr runtime
-    BUILDR_PATHS = [File.expand_path('../', File.dirname(__FILE__)),
-                    File.expand_path('../../lib', File.dirname(__FILE__))]
-
-    HELP = <<-HELP.strip.gsub(/ *\n +/, "\n  ")
-          NailGun is a client, protocol, and server for running Java 
-          programs from the command line without incurring the JVM
-          startup overhead. Nailgun integration is currently available
-          only when running Buildr with JRuby.
-
-          Buildr provides a custom nailgun server, allowing you to 
-          start a single JVM and let buildr create a queue of runtimes.
-          These JRuby runtimes can be cached (indexed by buildfile path)
-          and are automatically reloaded when the buildfile has been modified.
-          Runtime caching allows you to execute tasks without
-          spending time creating the buildr environment. Some nailgun 
-          tasks have been provided to manage the cached runtimes.
-
-          To start the buildr server execute the following task:
-
-              nailgun:start
-
-          Server output will display a message when it becomes ready, you
-          will also see messages when the JRuby runtimes are being created,
-          or when a new buildr environment is being loaded on them.
-          After the runtime queues have been populated, you can start calling
-          buildr as you normally do, by invoking the $NAILGUN_HOME/ng binary:
-
-              # on another terminal, change directory to a project.
-              # if this project is the same nailgun:start was invoked on, it's 
-              # runtime has been cached, so no loading is performed unless 
-              # the buildfile has been modified. otherwise the buildfile 
-              # will be loaded on a previously loaded fresh-buildr runtime
-              # and it will be cached.
-              cd /some/buildr/project
-              ng nailgun:help                 # display nailgun help
-              ng nailgun:tasks                # display overview of ng tasks
-              ng clean compile                # just invoke those two tasks
-
-             Configuration and Environment Variables.
-
-          Before starting the server, buildr will check if you have 
-          nailgun already installed by seeking the nailgun jar under
-
-              $NAILGUN_HOME
-
-          You can override this environment variable to tell buildr where
-          to find or where to install nailgun. If missing, NAILGUN_HOME
-          defaults to the $JRUBY_HOME/tool/nailgun directory.
-
-          Buildr will also check that the nailgun client binary (ng.exe for 
-          Windows systems, ng otherwise) is installed on NAILGUN_HOME. 
-          If no binary is found, buildr will download nailgun and 
-          compile+install it.          
-          
-          The buildr server binds itself to localhost, port 2113. You can 
-          override this when starting the nailgun server:
-
-              buildr nailgun:start[4444,127.0.0.1]
-
-          If you provided custom host/port settings you need
-          to tell the nailgun client where to connect:
-
-              ng --nailgun-server 127.0.0.1 --nailgun-port 4444 nailgun:tasks
-
-          The buildr server starts a RuntimeFactory responsible for providing
-          a pool of preloaded Buildr runtimes ready for task execution. 
-          You can provide a third argument to the nailgun:start task, to set
-          the buildr queue size. You may want to increase this value if you
-          need to load many buildfiles on the same server.
- 
-          Execute nailgun:tasks get an overview of available nailgun tasks.
-    HELP
-
-    private
+    PORT = DRbApplication::PORT + 2
+    ADDON_BIN = File.dirname(__FILE__)
     
     # Returns the path to JRUBY_HOME.
     def jruby_home
@@ -125,152 +61,9 @@ module Buildr #:nodoc:
       File.join(Dir.tmpdir, 'nailgun', *paths)
     end
 
-    file_tasks = lambda 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'))
-      ng.artifact = Buildr.artifact(ARTIFACT_SPEC).from(nailgun_jar)
-      unless File.exist?(nailgun_jar.to_s)
-        nailgun_jar.enhance [dist_dir]
-      end
-      
-      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
-      
-      ng.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
-      
-    end # file_tasks
-
-    server_tasks = lambda do 
-
-      desc 'Start the nailgun server'
-      task('start', :port, :iface, :queue_size) do |task, args|
-        
-        [ng.installed_bin, ng.artifact].map(&:invoke)
-        
-        iface = args[:iface].to_s.empty? ? '127.0.0.1' : args[:iface]
-        port  = args[:port].to_s.empty? ? 2113 : args[:port].to_i
-        queue_size = args[:queue_size].to_s.empty? ? 3 : args[:queue_size].to_i
-
-        fail "Already running on Nailgun server: #{ng.server || ng.nail}" if ng.server || ng.client
-        
-        info 'Booting Buildr nailgun server...'
-        top_level = Buildr.application.instance_eval { @top_level_tasks.dup }
-        top_level.delete_if { |t| t[/nailgun/] }
-        unless top_level.empty?
-          raise 'Don\'t specify more targets when starting Nailgun server: #{top_level}'
-        end
-        ng.server_setup.call
-
-        factory = RuntimeFactory.new(queue_size, queue_size)
-        ng.server = NGServer.new(iface, port, factory)
-
-        ng.server.start
-      end
-
-      desc 'Show nailgun help'
-      task('help') do
-        info HELP
-        exit(0)
-      end
-      
-      desc 'List nailgun tasks'
-      task('tasks') do
-        task_hash = Buildr.application.instance_variable_get(:@tasks)
-        tasks = task_hash.keys.select { |k| k =~ /^nailgun:/ }
-        width = [tasks.map { |t| task_hash[t].name_with_args.size }, 20].flatten.max
-        tasks.each do |name|
-          task = task_hash[name]
-          title = task.name_with_args
-          comment = task.full_comment
-          info comment.empty? ? title : ("  %-#{width}s  # %s" % [title, comment])
-        end
-        exit(0)
-      end
-
-      desc 'List currently cached runtimes'
-      task('list') do
-        if Nailgun.ng.server
-          Nailgun.ng.server.cached_stamps.each_pair do |bf, time|
-            loaded = Nailgun.ng.server.loaded_times[bf]
-            ary = [bf, "Load Timestamp", loaded, "Modification Timestamp", time]
-            info("* %s\n  %-25s %s\n  %-25s %s\n\n" % ary)
-          end
-        else
-          info "Not running on nailgun server"
-        end
-        exit(0)
-      end
-
-      desc 'Remove all cached runtimes'
-      task('clear') do
-        if Nailgun.ng.server
-          Nailgun.ng.server.cached_runtimes.clear
-          Nailgun.ng.server.cached_stamps.clear
-          Nailgun.ng.server.loaded_times.clear
-          info "Cleared all cached runtimes"
-        else
-          info "Not running on nailgun server"
-        end
-        exit(0)
-      end
-
-      desc 'Remove runtime for this buildfile'
-      task('delete', :buildfile) do |task, args|
-        if Nailgun.ng.server
-          if args[:buildfile]
-            buildfile = File.expand_path(args[:buildfile])
-          else
-            buildfile = Buildr.application.buildfile.to_s
-          end
-          Nailgun.ng.server.cached_runtimes.delete(buildfile)
-          Nailgun.ng.server.cached_stamps.delete(buildfile)
-          Nailgun.ng.server.loaded_times.delete(buildfile)
-          info "Deleted #{buildfile} from runtime cache"
-        else
-          info "Not running on nailgun server"
-        end
-        exit(0)
-      end
-
-    end # server_tasks
-
-    # Load java classes on server side.
-    ng.server_setup = lambda do 
-
-      module Util
-        include Buildr::Util
-      end
-
-      Util.add_to_sysloader ng.artifact.to_s
-      Util.add_to_sysloader File.dirname(__FILE__)
-
-      class NGClient
-        include org.apache.buildr.BuildrNail
-        include Client
-      end
-
-      class NGServer < com.martiansoftware.nailgun.NGServer
-        include Server
-      end
-
-    end # server_setup
-    
     module Util
       extend self
-      
+
       def add_to_sysloader(path)
         sysloader = java.lang.ClassLoader.getSystemClassLoader
         add_url_method = java.lang.Class.forName('java.net.URLClassLoader').
@@ -279,43 +72,6 @@ module Buildr #:nodoc:
         add_url_method.invoke(sysloader, [java.io.File.new(path).toURI.toURL].to_java(java.net.URL))
       end
 
-      def benchmark(action = ['Completed'], verbose = true)
-        result = nil
-        times = Benchmark.measure do
-          result = yield(action)
-        end
-        if verbose
-          real = []
-          real << ("%ih" % (times.real / 3600)) if times.real >= 3600
-          real << ("%im" % ((times.real / 60) % 60)) if times.real >= 60
-          real << ("%.3fs" % (times.real % 60))
-          trace "#{[action].flatten.join(' ')} in #{real.join}"
-        end
-        result
-      end
-
-      def find_file(pwd, candidates, nosearch=false)
-        candidates = [candidates].flatten
-        buildfile = candidates.find { |c| File.file?(File.expand_path(c, pwd)) }
-        return File.expand_path(buildfile, pwd) if buildfile
-        return nil if nosearch
-        updir = File.dirname(pwd)
-        return nil if File.expand_path(updir) == File.expand_path(pwd)
-        find_file(updir, candidates)
-      end
-
-      def exception_handling(raise_again = true, show_error = true)
-        begin
-          yield
-        rescue => e
-          if show_error
-            error "#{e.backtrace.shift}: #{e.message}"
-            e.backtrace.each { |i| error "\tfrom #{i}" }
-          end
-          raise if raise_again
-        end
-      end
-
       # invoke a java constructor
       def ctor(on_class, *args)
         parameters = []
@@ -341,300 +97,36 @@ module Buildr #:nodoc:
         ctor.newInstance(parameters.to_java(java.lang.Object))
       end
 
-      def on_runtime(runtime, *args, &block)
-        raise_error = lambda do |cls, msg, trace|
-          raise RuntimeError.new(cls + ": "+ msg.to_s).tap { |e| e.set_backtrace(trace.map(&:to_s)) }
-        end
-        executor = runtime.object.const_get(:Module).new do
-          extend self
-          def runtime_exec(*args, &prc)
-            define_method(:runtime_exec, &prc)
-            runtime_exec(*args)
-          rescue => e
-            [:error, e.class.name, e.message, e.backtrace]
-          end
-        end
-        result = executor.runtime_exec(*args, &block)
-        raise_error.call(*result[1..-1]) if result.kind_of?(Array) && result.first == :error
-        result
-      end
-
-      def set_stdio(runtime, dev)
-        set_global = lambda do |global, constant, stream|
-          runtime.global_variables.set(global, stream)
-          runtime.object.send(:remove_const, constant)
-          runtime.object.send(:const_set, constant, stream)
-        end
-        stdin  = runtime.global_variables.get('$stdin')
-        stdout = runtime.global_variables.get('$stdout')
-        stderr = runtime.global_variables.get('$stderr')
-        #stdin.close; stdout.close; stderr.close;
-        output = Util.ctor(org.jruby.RubyIO, runtime, java.io.OutputStream => dev.out)
-        error = Util.ctor(org.jruby.RubyIO, runtime, java.io.OutputStream => dev.err)
-        input = Util.ctor(org.jruby.RubyIO, runtime, java.io.InputStream => dev.in)
-        #stdin.reopen(input, 'r') # not working on jruby, :(
-        #stdout.reopen(output, 'w')
-        #stderr.reopen(error, 'w')
-        set_global.call('$stdin', 'STDIN', input)
-        set_global.call('$stdout', 'STDOUT', output)
-        set_global.call('$stderr', 'STDERR', error)
-      end
-
-    end # module Util
-
-    class FieldAccessor
-      def initialize(obj, clazz = nil)
-        @obj = obj
-        clazz ||= obj.class
-        @cls = [clazz.java_class].to_java(java.lang.Class)[0]
-      end
-
-      def [](name)
-        field = @cls.getDeclaredField(name.to_s)
-        field.setAccessible(true)
-        field.get(@obj)
-      end
-      
-      def []=(name, value)
-        field = @cls.getDeclaredField(name.to_s)
-        field.setAccessible(true)
-        field.set(@obj, value)
-      end
-      
-      def method_missing(name, value =nil)
-        if name.to_s =~ /=$/
-          self[name.to_s.chomp('=')] = value
-        else
-          self[name]
-        end
-      end
-    end
-
-    module NailMethods
-        
-      def self.extend_object(obj)
-        super
-        (class << obj; self; end).module_eval do
-          alias_method :pwd, :getWorkingDirectory
-          alias_method :server, :getNGServer
-        end
-      end
-      
-      def argv
-        [command] + args
-      end
-
-      def attach_runtime(runtime)
-        runtime.extend RuntimeMixin
-        runtime.evalScriptlet %q{
-          require 'ostruct'
-          module Buildr
-            module Nailgun
-              extend self
-              attr_reader :ng
-              @ng = OpenStruct.new
-            end
-          end
-        }
-        runtime.Buildr::Nailgun.ng.nail = self
-        runtime.load_service.require __FILE__
-        runtime
-      end
-      private :attach_runtime
-      
-      def jruby
-        @jruby ||= server.runtime_factory.new_jruby.tap do |runtime|
-          attach_runtime(runtime)
-        end
-      end
-      
-      def buildr
-        @buildr ||= server.runtime_factory.new_buildr.tap do |runtime|
-          attach_runtime(runtime)
-        end
-      end
-      
-      def options
-        @options ||= OpenStruct.new
-      end
-      
-    end # NailMethods
-
-    module RuntimeMixin
-      def Buildr
-        object.const_get(:Buildr)
-      end
-    end
-    
-    module AppMixin        
-      def load_tasks
-        trace "Not loading tasks again"
-      end
-      
-      def load_buildfile
-        trace "Not loading buildfile again"
-      end        
-    end
+    end # Util
 
     module Client
 
-      class << self
-        include Buildr::CommandLineInterface
-
-        def options
-          Nailgun.ng.nail.options
-        end
-
-        def rakefiles
-          Nailgun.ng.nail.options.rakefiles
-        end
-
-        def requires
-          Nailgun.ng.nail.options.requires
-        end
-        
-        def help
-          super
-          puts 
-          puts 'To get a summary of Nailgun features use'
-          puts '  nailgun:help'        
-        end
-
-        def version
-          puts super
-        end
+      def main(nail)
+        nail.out.println "Connected to #{nail.getNGServer}"
 
-        def do_option(opt, value)
-          case opt
-          when '--help'
-            options.exit = :help
-          when '--version'
-            options.exit = :version
-          when '--nosearch'
-            options.nosearch = true
-          else
-            super
-          end
-        end
+        runtime = JRuby.runtime
 
-        def sBuildr
-          Nailgun.ng.nail.server.runtime.object.const_get(:Buildr)
-        end
+        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)
         
-        def attach_runtime
-          nail = Nailgun.ng.nail
-          ARGV.replace nail.argv
-          Dir.chdir nail.pwd
-          nail.env.each { |k, v| ENV[k.to_s] = v.to_s }
-          
-          Buildr.const_set(:VERSION, sBuildr::VERSION) unless Buildr.const_defined?(:VERSION)
-          nail.options.rakefiles = sBuildr::Application::DEFAULT_BUILDFILES.dup
-          nail.options.requires = []
-        end
+        dir = nail.getWorkingDirectory
+        argv = [nail.command] + nail.args
         
-        def client(runtime, nail, &block)
-          Util.set_stdio(runtime, nail)
-          nailgun_module = runtime.Buildr::Nailgun
-          nailgun_module.ng.nail = nail
-          nailgun_module::Client.attach_runtime
-          nailgun_module::Client.instance_eval(&block)
-        end
-      end
-
-      def main(nail)
-        nail.extend NailMethods
-        info "Got connection from #{nail.pwd}"
-
-        Client.client(nail.jruby, nail) do
-          
-          parse_options
-          if options.exit
-            send(options.exit)
-            nail.exit(0)
-          end
-
-          if options.project && File.directory?(options.project)
-            Dir.chdir(options.project)
-          end
-          
-          bf = Util.find_file(Dir.pwd, options.rakefiles, options.nosearch)
-          unless bf
-            nail.out.println "No buildfile found at #{Dir.pwd}"
-            nail.exit(0)
-          end
-          
-          rt = nail.server.cached_runtimes[bf]
-          old_stamp = nail.server.cached_stamps[bf] || Rake::EARLY
-          new_stamp = rt ? rt.Buildr.application.buildfile.timestamp : Rake::EARLY
-          
-          if rt.nil? || new_stamp > old_stamp
-            rt = nail.buildr
-            app = rt.Buildr.application
-            app.instance_variable_set(:@rakefile, bf)
-            nail.out.println "Currently nailgun has issues reloading buildfiles, will get fixed in next release."
-            nail.out.println "Restart your nailgun server."
-            return nail.exit(1)
-          else
-            app = rt.Buildr.application.extend AppMixin
-            app.lookup('buildr:initialize').instance_eval do 
-              @already_invoked = false
-              @actions = []
-            end
-            app.instance_eval do
-              @tasks.values.each do |task|
-                is_project = rt.Buildr::Project.instance_variable_get(:@projects).key?(task.name)
-                task.instance_variable_set(:@already_invoked, false) unless is_project
-              end
-            end
-          end
-
-          app.instance_eval do
-            @original_dir = nail.pwd
-          end
-
-          Client.client(rt, nail) do
-            Util.exception_handling do
-              begin
-                app.parse_options
-                app.collect_tasks
-                app.run
-              rescue SystemExit => e
-                nail.exit(1)
-              end
-            end
-          end
-
-          nail.server.cache(rt, app.buildfile)
-        end
+        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 # class Client
+    end # Client
 
     module Server
-
-      attr_reader :runtime_factory
-      attr_reader :cached_runtimes
-      attr_reader :cached_stamps
-      attr_reader :loaded_times
-
-      def initialize(host = 'localhost', port = 2113, buildr_factory = nil)
-        super(java.net.InetAddress.get_by_name(host), port)
-        @cached_runtimes = {}
-        @cached_stamps = {}
-        @loaded_times = {}
-        cache(runtime, Buildr.application.buildfile)
-        @runtime_factory = buildr_factory
-        @host, @port = host, port
-      end
-
-      def cache(runtime, buildfile)
-        cached_runtimes[buildfile.to_s] = runtime
-        cached_stamps[buildfile.to_s] = buildfile.timestamp
-        loaded_times[buildfile.to_s] = Time.now
-      end
-
-      def runtime
-        JRuby.runtime.extend RuntimeMixin
+      def initialize(host, port)
+        @host = host || "*"
+        @port = port
+        super(host, port)
       end
 
       def start
@@ -642,7 +134,6 @@ module Buildr #:nodoc:
         
         NGClient::Main.nail = NGClient.new
         self.default_nail_class = NGClient::Main
-        runtime_factory.start
         
         @thread = java.lang.Thread.new(self)
         @thread.setName(to_s)
@@ -653,165 +144,78 @@ module Buildr #:nodoc:
       end
       
       def stop
-        runtime_factory.stop
         @thread.kill
       end
 
       def to_s
-        self.class.name+'('+[Buildr.application.version, @host, @port].join(', ')+')'
+        version = "Buildr #{Buildr::VERSION} #{RUBY_PLATFORM[/java/] && '(JRuby '+JRUBY_VERSION+')'}"
+        self.class.name+'('+[version, @host, @port].join(', ')+')'
       end
-    end # module Server
-    
-    class RuntimeFactory
-      
-      attr_accessor :buildrs_size, :jrubys_size
-      
-      def initialize(buildrs_size = 1, jrubys_size = nil)
-        # jrubys_size ||= buildrs_size
-        @buildrs_size = buildrs_size < 1 ? 1 : buildrs_size
-        # @jrubys_size = jrubys_size < 1 ? 1 : jrubys_size
+    end # Server
 
-        @buildrs = [].extend(MonitorMixin)
-        @buildrs_ready = @buildrs.new_cond
-        @buildrs_needed = @buildrs.new_cond
-        
-        @buildrs_creators = [].extend(MonitorMixin)
+    namespace(:nailgun) do
 
-        # @jrubys = [].extend(MonitorMixin)
-        # @jrubys_ready = @jrubys.new_cond
-        # @jrubys_needed = @jrubys.new_cond
-        
-        # @jrubys_creators = [].extend(MonitorMixin)
-      end
+      dist_zip = Buildr.download(tmp_path(NAME + '.zip') => URL)
+      dist_dir = Buildr.unzip(tmp_path(NAME) => dist_zip)
       
-      def new_buildr
-        get(:buildr)
-      end
+      nailgun_jar = file(tmp_path(NAME, NAME, NAME + '.jar'))
+      nailgun_jar.enhance [dist_dir] unless File.exist?(nailgun_jar.to_s)
 
-      def new_jruby(&block)
-        # get(:jruby)
-        create_jruby(0, &block)
+      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
 
-      def start
-        trace "Starting Buildr runtime factory"
-        # @jruby_creator = Thread.new { loop { create :jruby } }
-        # @jruby_creator.priority = -2
-        @buildr_creator = Thread.new { loop { create :buildr } }
-        @buildr_creator.priority = 1
+      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
 
-      def stop
-        @buildr_creator.kill if @buildr_creator
-        # @jruby_creator.kill if @jruby_creator
+      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
 
-      private
-      def get(thing)
-        collection = instance_variable_get("@#{thing}s")
-        needs = instance_variable_get("@#{thing}s_needed")
-        ready = instance_variable_get("@#{thing}s_ready")
-        result = nil
-        collection.synchronize do 
-          if collection.empty?
-            trace "no #{thing} available, ask to create more"
-            needs.broadcast
-            trace "should be creating #{thing}"
-            ready.wait_while { collection.empty? }
-          end
-          trace "Getting my #{thing}"
-          result = collection.shift
-          trace "would need more #{thing}s"
-          needs.broadcast
-          trace "got my #{thing}: #{result.inspect}"
-          Thread.pass
-        end
-        trace "returning #{result.inspect}"
-        result
+      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
 
-      def create(thing, *args, &block)
-        Util.exception_handling do
-          creator = needed(thing)
-          collection = instance_variable_get("@#{thing}s")
-          ready = instance_variable_get("@#{thing}s_ready")
-          needs = instance_variable_get("@#{thing}s_needed")
-          unless creator
-            collection.synchronize do
-              trace "awake those wanting a #{thing}"
-              ready.broadcast
-              Thread.pass
-              trace "wait until more #{thing}s are needed"
-              # needs.wait(1); return
-              needs.wait_until { creator = needed(thing) }
-            end
-          end
-          trace "About to create #{thing} # #{creator}"
-          method = "create_#{thing}"
-          creators = instance_variable_get("@#{thing}s_creators")
-          trace "registering creator for #{thing} #{creator}"
-          creators.synchronize { creators << creator }
-          result = send(method, creator, *args, &block)
-          trace "created #{thing}[#{creator}] => #{result.inspect}"
-          creators.synchronize do 
-            trace "unregistering creator for #{thing} #{creator}"
-            creators.delete(creator)
-            collection.synchronize do
-              trace "adding object on queue for #{thing} #{creator}"
-              collection << result
-            end
-          end
+      task('setup' => artifact) do 
+        module Util
+          include Buildr::Util
         end
-      end
-      
-      def needed(thing)
-        collection = instance_variable_get("@#{thing}s")
-        creators = instance_variable_get("@#{thing}s_creators")
-        size = instance_variable_get("@#{thing}s_size")
-        collection.synchronize do
-          count = collection.size
-          if count < size
-            count += creators.synchronize { creators.size }
-          end
-          count if count < size
+        
+        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
       
-      def create_jruby(creator, &block)
-        Util.exception_handling do
-          trace "Creating jruby[#{creator}]"
-          Util.benchmark do |header|
-            cfg = org.jruby.RubyInstanceConfig.new
-            yield cfg if block_given?
-            jruby = org.jruby.Ruby.newInstance(cfg)
-            jruby.load_service.load_path.unshift *BUILDR_PATHS
-            header.replace ["Created jruby[#{creator}]", jruby]
-            jruby
-          end
-        end
-      end
-
-      def create_buildr(creator)
-        Util.exception_handling do 
-          trace "Obtaining jruby to load buildr[#{creator}] on it"
-          jruby = new_jruby
-          trace "Loading buildr[#{creator}] on #{jruby} ..."
-          Util.benchmark ["Loaded buildr[#{creator}] on #{jruby}"] do
-            load_service = jruby.load_service
-            load_service.require 'rubygems'
-            load_service.require 'buildr'
-          end
-          jruby
-        end
-      end
+    end # ng_tasks
       
-    end # RuntimeFactory
-
-    if Buildr.respond_to?(:application) && ng.nail.nil?
-      Buildr.application.in_namespace(:nailgun, &file_tasks)
-      Buildr.application.in_namespace(:nailgun, &server_tasks)
-    end
-
   end # module Nailgun
-  
 end