jettywrapper 0.0.7 → 0.0.8

data/.gitmodules

@@ -1,3 +1,6 @@
 [submodule "jetty1"]
 	path = jetty1
 	url = git://github.com/projecthydra/hydra-jetty.git
+[submodule "jetty2"]
+	path = jetty2
+	url = git://github.com/projecthydra/hydra-jetty.git

data/Rakefile

@@ -4,7 +4,7 @@ require 'spec/rake/spectask'
 require 'yard'
 
 Bundler::GemHelper.install_tasks
-Dir.glob('lib/tasks/*.rake').each { |r| import r }
+Dir.glob('tasks/*.rake').each { |r| import r }
 
 
 begin

data/TODO.txt

@@ -0,0 +1,3 @@
+Next up:
+
+Check whether a port is open before you attempt to start jetty. I've put a method in place, but I need to work on something else for awhile and I haven't fully implemented this yet. 

data/lib/jettywrapper.rb

@@ -4,6 +4,9 @@ require 'logger'
 require 'loggable'
 require 'singleton'
 require 'ftools'
+require 'socket'
+require 'timeout'
+require 'ruby-debug'
 
 class Jettywrapper
   
@@ -32,6 +35,8 @@ class Jettywrapper
     @logger.debug 'Initializing jettywrapper'
   end
   
+  # Methods inside of the class << self block can be called directly on Jettywrapper, as class methods. 
+  # Methods outside the class << self block must be called on Jettywrapper.instance, as instance methods.
   class << self
     
     # Set the jetty parameters. It accepts a Hash of symbols. 
@@ -76,7 +81,7 @@ class Jettywrapper
     #     end 
     #     raise "test failures: #{error}" if error
     #   end
-    def wrap(params = {})
+    def wrap(params)
       error = false
       jetty_server = self.instance
       jetty_server.quiet = params[:quiet] || true
@@ -102,6 +107,86 @@ class Jettywrapper
       return error
     end
     
+    # Convenience method for configuring and starting jetty with one command
+    # @param [Hash] params: The configuration to use for starting jetty
+    # @example 
+    #    Jettywrapper.start_with_params(:jetty_home => '/path/to/jetty', :jetty_port => '8983')
+    def start(params)
+       Jettywrapper.configure(params)
+       Jettywrapper.instance.start
+       return Jettywrapper.instance
+    end
+    
+    # Convenience method for configuring and starting jetty with one command. Note
+    # that for stopping, only the :jetty_home value is required (including other values won't 
+    # hurt anything, though). 
+    # @param [Hash] params: The jetty_home to use for stopping jetty
+    # @return [Jettywrapper.instance]
+    # @example 
+    #    Jettywrapper.stop_with_params(:jetty_home => '/path/to/jetty')
+    def stop(params)
+       Jettywrapper.configure(params)
+       Jettywrapper.instance.stop
+       return Jettywrapper.instance
+    end
+    
+    # Determine whether the jetty at the given jetty_home is running
+    # @param [Hash] params: :jetty_home is required. Which jetty do you want to check the status of?
+    # @return [Boolean]
+    # @example
+    #    Jettywrapper.is_running?(:jetty_home => '/path/to/jetty')
+    def is_jetty_running?(params)      
+      Jettywrapper.configure(params)
+      pid = Jettywrapper.instance.pid
+      return false unless pid
+      true
+    end
+    
+    # Return the pid of the specified jetty, or return nil if it isn't running
+    # @param [Hash] params: :jetty_home is required.
+    # @return [Fixnum] or [nil]
+    # @example
+    #    Jettywrapper.pid(:jetty_home => '/path/to/jetty')
+    def pid(params)
+      Jettywrapper.configure(params)
+      pid = Jettywrapper.instance.pid
+      return nil unless pid
+      pid
+    end
+    
+    # Check to see if the port is open so we can raise an error if we have a conflict
+    # @param [Fixnum] port the port to check
+    # @return [Boolean]
+    # @example
+    #  Jettywrapper.is_port_open?(8983)
+    def is_port_in_use?(port)
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new('127.0.0.1', port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          rescue
+            return false
+          end
+        end
+      rescue Timeout::Error
+      end
+
+      return false
+    end
+    
+    # Check to see if the pid is actually running. This only works on unix. 
+    def is_running?(pid)
+      begin
+        return Process.getpgid(pid) != -1
+      rescue Errno::ESRCH
+        return false
+      end
+    end
+    
     end #end of class << self
     
         
@@ -112,21 +197,32 @@ class Jettywrapper
    
    # Start the jetty server. Check the pid file to see if it is running already, 
    # and stop it if so. After you start jetty, write the PID to a file. 
+   # This is the instance start method. It must be called on Jettywrapper.instance
+   # You're probably better off using Jettywrapper.start(:jetty_home => "/path/to/jetty")
+   # @example
+   #    Jettywrapper.configure(params)
+   #    Jettywrapper.instance.start
+   #    return Jettywrapper.instance
    def start
      @logger.debug "Starting jetty with these values: "
      @logger.debug "jetty_home: #{@jetty_home}"
      @logger.debug "solr_home: #{@solr_home}"
      @logger.debug "fedora_home: #{@fedora_home}"
      @logger.debug "jetty_command: #{jetty_command}"
-          
+     
+     # Check to see if we can start.
+     # 1. If there is a pid, check to see if it is really running
+     # 2. Check to see if anything is blocking the port we want to use     
      if pid
-       begin
-         Process.kill(0,pid)
+       if Jettywrapper.is_running?(pid)
          raise("Server is already running with PID #{pid}")
-       rescue Errno::ESRCH
+       else
          @logger.warn "Removing stale PID file at #{pid_path}"
          File.delete(pid_path)
        end
+       if Jettywrapper.is_port_in_use?(@jetty_port)
+         raise("Port #{self.jetty_port} is already in use.")
+       end
      end
      Dir.chdir(@jetty_home) do
        self.send "#{platform}_process".to_sym
@@ -142,36 +238,47 @@ class Jettywrapper
      @logger.debug "Wrote pid file to #{pid_path} with value #{@pid}"
    end
  
-   def stop
-     @logger.warn "stopping jetty... "
+   # Instance stop method. Must be called on Jettywrapper.instance
+   # You're probably better off using Jettywrapper.stop(:jetty_home => "/path/to/jetty")
+   # @example
+   #    Jettywrapper.configure(params)
+   #    Jettywrapper.instance.stop
+   #    return Jettywrapper.instance
+   def stop    
      if pid
        begin
          self.send "#{platform}_stop".to_sym
        rescue Errno::ESRCH
-         @logger.warn "Removing stale PID file at #{pid_path}"
+         @logger.error "I tried to kill the process #{pid} but it seems it wasn't running."
+       end
+       begin
+         File.delete(pid_path)
+       rescue
        end
-       FileUtils.rm(pid_path)
      end
    end
  
-   def win_process
-     @pid = Process.create(
-           :app_name         => jetty_command,
-           :creation_flags   => Process::DETACHED_PROCESS,
-           :process_inherit  => false,
-           :thread_inherit   => true,
-           :cwd              => "#{@jetty_home}"
-        ).process_id
-   end
+    # Spawn a process on windows
+    def win_process
+      @pid = Process.create(
+         :app_name         => jetty_command,
+         :creation_flags   => Process::DETACHED_PROCESS,
+         :process_inherit  => false,
+         :thread_inherit   => true,
+         :cwd              => "#{@jetty_home}"
+      ).process_id
+    end
 
-   def platform
-     case RUBY_PLATFORM
-     when /mswin32/
-       return 'win'
-     else
-       return 'nix'
-     end
-   end
+    # Determine whether we're running on windows or unix. We need to know this so 
+    # we know how to start and stop processes. 
+    def platform
+      case RUBY_PLATFORM
+        when /mswin32/
+           return 'win'
+        else
+           return 'nix'
+      end
+    end
 
    def nix_process
      @pid = fork do
@@ -187,18 +294,43 @@ class Jettywrapper
 
    # stop jetty the *nix way
    def nix_stop
-     @logger.debug "Killing process #{pid}"
-     Process.kill('TERM',pid)
+     return nil if pid == nil
+     begin
+       pid_keeper = pid
+       @logger.debug "Killing process #{pid}"
+       Process.kill('TERM',pid)
+       sleep 2
+       FileUtils.rm(pid_path)
+       if Jettywrapper.is_running?(pid_keeper)
+         raise "Couldn't kill process #{pid_keeper}"
+       end
+     rescue Errno::ESRCH
+       @logger.debug "I tried to kill #{pid_keeper} but it appears it wasn't running."
+     end
    end
 
+   # The fully qualified path to the pid_file
    def pid_path
      File.join(pid_dir, pid_file)
    end
 
    # The file where the process ID will be written
    def pid_file
-     @pid_file || 'hydra-jetty.pid'
+     @pid_file || jetty_home_to_pid_file(@jetty_home)
    end
+   
+    # Take the @jetty_home value and transform it into a legal filename
+    # @return [String] the name of the pid_file
+    # @example
+    #    /usr/local/jetty1 => _usr_local_jetty1.pid
+    def jetty_home_to_pid_file(jetty_home)
+      begin
+        jetty_home.gsub(/\//,'_') << ".pid"
+      rescue
+        raise "Couldn't make a pid file for jetty_home value #{jetty_home}"
+        raise $!
+      end
+    end
 
    # The directory where the pid_file will be written
    def pid_dir
@@ -212,6 +344,7 @@ class Jettywrapper
       false
    end
 
+   # the process id of the currently running jetty instance
    def pid
       @pid || File.open( pid_path ) { |f| return f.gets.to_i } if File.exist?(pid_path)
    end

data/lib/jettywrapper/version.rb

@@ -1 +1 @@
-GEMVERSION = "0.0.7"
+GEMVERSION = "0.0.8"

data/spec/lib/jettywrapper_integration_spec.run_by_hand

@@ -0,0 +1,137 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+require File.join(File.dirname(__FILE__), "/../../lib/jettywrapper")
+require 'rubygems'
+require 'ruby-debug'
+require 'uri'
+
+module Hydra
+  describe Jettywrapper do    
+    context "integration" do
+      before(:all) do
+        $stderr.reopen("/dev/null", "w")
+      end
+      
+      it "starts" do
+        jetty_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1")
+        }
+        Jettywrapper.configure(jetty_params) 
+        ts = Jettywrapper.instance
+        ts.logger.debug "Stopping jetty from rspec."
+        ts.stop
+        ts.start      
+        ts.logger.debug "Jetty started from rspec at #{ts.pid}"
+        pid_from_file = File.open( ts.pid_path ) { |f| f.gets.to_i }
+        ts.pid.should eql(pid_from_file)
+        sleep 30 # give jetty time to start
+      
+        # Can we connect to solr?
+        require 'net/http' 
+        response = Net::HTTP.get_response(URI.parse("http://localhost:8888/solr/admin/"))
+        response.code.should eql("200")
+        ts.stop
+      
+      end
+      
+      it "won't start if it's already running" do
+        jetty_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1")
+        }
+        Jettywrapper.configure(jetty_params) 
+        ts = Jettywrapper.instance
+        ts.logger.debug "Stopping jetty from rspec."
+        ts.stop
+        ts.start
+        sleep 30
+        ts.logger.debug "Jetty started from rspec at #{ts.pid}"
+        response = Net::HTTP.get_response(URI.parse("http://localhost:8888/solr/admin/"))
+        response.code.should eql("200")
+        lambda { ts.start }.should raise_exception(/Server is already running/)
+        ts.stop
+      end
+      
+      it "can start multiple copies of jetty, as long as they have different jetty_homes" do
+        jetty1_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1"),
+          :jetty_port => '8983'
+        }
+        jetty2_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty2"),
+          :jetty_port => '8984'
+        }
+        
+        # Ensure nothing is running when we start
+        Jettywrapper.stop(jetty1_params) 
+        Jettywrapper.stop(jetty2_params)
+        
+        # Spin up two copies of jetty, with different jetty home values and on different ports
+        Jettywrapper.start(jetty1_params) 
+        Jettywrapper.start(jetty2_params) 
+        
+        # Ensure both are viable
+        sleep 30
+        response1 = Net::HTTP.get_response(URI.parse("http://localhost:8983/solr/admin/"))
+        response1.code.should eql("200")
+        response2 = Net::HTTP.get_response(URI.parse("http://localhost:8984/solr/admin/"))
+        response2.code.should eql("200")
+        
+        # Shut them both down
+        Jettywrapper.stop(jetty1_params) 
+        Jettywrapper.stop(jetty2_params)
+      end
+      
+      it "raises an error if you try to start a jetty that is already running" do
+        jetty_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1"),
+          :jetty_port => '8983'
+        }
+        ts = Jettywrapper.configure(jetty_params) 
+        ts.stop
+        ts.pid_file?.should eql(false)
+        ts.start
+        sleep 30
+        lambda{ ts.start }.should raise_exception
+        ts.stop
+      end
+      
+      it "can check to see whether a port is already in use" do
+        params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1"),
+          :jetty_port => '9999'
+        }
+        Jettywrapper.stop(params) 
+        sleep 10
+        Jettywrapper.is_port_in_use?(params[:jetty_port]).should eql(false)
+        Jettywrapper.start(params) 
+        sleep 30
+        Jettywrapper.is_port_in_use?(params[:jetty_port]).should eql(true)
+        Jettywrapper.stop(params) 
+      end
+      
+      # Not ready for this yet
+      # it "won't start if there is a port conflict" do
+      #   jetty1_params = {
+      #     :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1"),
+      #     :jetty_port => '8983'
+      #   }
+      #   jetty2_params = {
+      #     :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty2"),
+      #     :jetty_port => '8983'
+      #   }
+      #   # Ensure nothing is running when we start
+      #   Jettywrapper.stop(jetty1_params) 
+      #   Jettywrapper.stop(jetty2_params)
+      #   
+      #   # Spin up two copies of jetty, with different jetty home values but the same port
+      #   Jettywrapper.start(jetty1_params) 
+      #   lambda{ Jettywrapper.start(jetty2_params) }.should raise_exception
+      #   
+      #   # Shut them both down
+      #   Jettywrapper.stop(jetty1_params) 
+      #   Jettywrapper.stop(jetty2_params)
+      # end
+      
+    end
+    
+  end
+end

data/spec/lib/jettywrapper_spec.rb

@@ -6,6 +6,8 @@ require 'ruby-debug'
 module Hydra
   describe Jettywrapper do
     
+    # JETTY1 = 
+    
     before(:all) do
       @jetty_params = {
         :quiet => false,
@@ -72,13 +74,72 @@ module Hydra
         }
         ts = Jettywrapper.configure(jetty_params) 
         Jettywrapper.any_instance.stubs(:fork).returns(5454)
+        ts.stop
         ts.start
         ts.pid.should eql(5454)
+        ts.stop
+      end
+      
+      it "can pass params to a start method" do
+        jetty_params = {
+          :jetty_home => '/tmp', :jetty_port => 8777
+        }
+        ts = Jettywrapper.configure(jetty_params) 
+        ts.stop
+        Jettywrapper.any_instance.stubs(:fork).returns(2323)
+        swp = Jettywrapper.start(jetty_params)
+        swp.pid.should eql(2323)
+        swp.pid_file.should eql("_tmp.pid")
+        swp.stop
+      end
+      
+      it "checks to see if its pid files are stale" do
+        @pending
+      end
+      
+      # return true if it's running, otherwise return false
+      it "can get the status for a given jetty instance" do
+        # Don't actually start jetty, just fake it
+        Jettywrapper.any_instance.stubs(:fork).returns(12345)
+        
+        jetty_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1")
+        }
+        Jettywrapper.stop(jetty_params)
+        Jettywrapper.is_jetty_running?(jetty_params).should eql(false)
+        Jettywrapper.start(jetty_params)
+        Jettywrapper.is_jetty_running?(jetty_params).should eql(true)
+        Jettywrapper.stop(jetty_params)
+      end
+      
+      it "can get the pid for a given jetty instance" do
+        # Don't actually start jetty, just fake it
+        Jettywrapper.any_instance.stubs(:fork).returns(54321)
+        jetty_params = {
+          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1")
+        }
+        Jettywrapper.stop(jetty_params)
+        Jettywrapper.pid(jetty_params).should eql(nil)
+        Jettywrapper.start(jetty_params)
+        Jettywrapper.pid(jetty_params).should eql(54321)
+        Jettywrapper.stop(jetty_params)
+      end
+      
+      it "can pass params to a stop method" do
+        jetty_params = {
+          :jetty_home => '/tmp', :jetty_port => 8777
+        }
+        Jettywrapper.any_instance.stubs(:fork).returns(2323)
+        swp = Jettywrapper.start(jetty_params)
+        (File.file? swp.pid_path).should eql(true)
+        
+        swp = Jettywrapper.stop(jetty_params)
+        (File.file? swp.pid_path).should eql(false)
       end
       
       it "knows what its pid file should be called" do
         ts = Jettywrapper.configure(@jetty_params) 
-        ts.pid_file.should eql("hydra-jetty.pid")
+        ts.pid_file.should eql("_path_to_jetty.pid")
       end
       
       it "knows where its pid file should be written" do
@@ -92,7 +153,7 @@ module Hydra
         }
         ts = Jettywrapper.configure(jetty_params) 
         Jettywrapper.any_instance.stubs(:fork).returns(2222)
-        FileUtils.rm(ts.pid_path)
+        ts.stop
         ts.pid_file?.should eql(false)
         ts.start
         ts.pid.should eql(2222)
@@ -101,21 +162,6 @@ module Hydra
         pid_from_file.should eql(2222)
       end
       
-      it "checks to see if jetty is running already before it starts" do
-        jetty_params = {
-          :jetty_home => '/tmp'
-        }
-        ts = Jettywrapper.configure(jetty_params) 
-        Jettywrapper.any_instance.stubs(:fork).returns(3333)
-        FileUtils.rm(ts.pid_path)
-        ts.pid_file?.should eql(false)
-        ts.start
-        ts.pid.should eql(3333)
-        Jettywrapper.any_instance.stubs(:fork).returns(4444)
-        ts.start
-        ts.pid.should eql(4444)
-      end
-      
     end # end of instantiation context
     
     context "logging" do
@@ -154,10 +200,10 @@ module Hydra
         Jettywrapper.any_instance.stubs(:start).returns(true)
         Jettywrapper.any_instance.stubs(:stop).returns(true)
         error = Jettywrapper.wrap(@jetty_params) do 
-          raise "foo"
+          raise "this is an expected error message"
         end
         error.class.should eql(RuntimeError)
-        error.message.should eql("foo")
+        error.message.should eql("this is an expected error message")
       end
       
     end # end of wrapping context

data/tasks/jettywrapper.rake

@@ -0,0 +1,136 @@
+# Note: These rake tasks are here mainly as examples to follow. You're going to want
+# to write your own rake tasks that use the locations of your jetty instances. 
+
+require 'jettywrapper'
+
+namespace :jettywrapper do
+  
+  jetty1 = {
+    :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../jetty1"),
+    :jetty_port => "8983"
+  }
+  
+  jetty2 = {
+    :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../jetty2"),
+    :jetty_port => "8984"
+  }
+  
+  namespace :status do
+    
+    desc "Return the status of jetty1"
+    task :jetty1 do
+      status = Jettywrapper.is_running?(jetty1) ? "Running: #{Jettywrapper.pid(jetty1)}" : "Not running"
+      puts status
+    end
+    
+    desc "Return the status of jetty2"
+    task :jetty2 do
+      status = Jettywrapper.is_running?(jetty2) ? "Running: #{Jettywrapper.pid(jetty2)}" : "Not running"
+      puts status
+    end
+    
+  end
+  
+  namespace :start do
+    
+    desc "Start jetty1"
+    task :jetty1 do
+        Jettywrapper.start(jetty1)
+        puts "jetty1 started at PID #{Jettywrapper.pid(jetty1)}"
+    end
+    
+    desc "Start jetty2"
+    task :jetty2 do
+        Jettywrapper.start(jetty2)
+        puts "jetty2 started at PID #{Jettywrapper.pid(jetty2)}"
+    end
+    
+  end
+  
+  namespace :stop do
+    
+    desc "stop jetty1"
+    task :jetty1 do
+      Jettywrapper.stop(jetty1)
+      puts "jetty1 stopped"
+    end
+    
+    desc "stop jetty2"
+    task :jetty2 do
+      Jettywrapper.stop(jetty2)
+      puts "jetty1 stopped"
+    end
+    
+  end
+  
+  namespace :restart do
+    
+    desc "Restarts jetty1"
+    task :jetty1 do
+      Jettywrapper.stop(jetty1)
+      Jettywrapper.start(jetty1)
+    end
+    
+    desc "Restarts jetty2"
+    task :jetty2 do
+      Jettywrapper.stop(jetty2)
+      Jettywrapper.start(jetty2)
+    end
+    
+  end
+
+    desc "Init Hydra configuration" 
+    task :init => [:environment] do
+      if !ENV["environment"].nil? 
+        RAILS_ENV = ENV["environment"]
+      end
+      
+      JETTY_HOME_TEST = File.expand_path(File.dirname(__FILE__) + '/../../jetty-test')
+      JETTY_HOME_DEV = File.expand_path(File.dirname(__FILE__) + '/../../jetty-dev')
+      
+      JETTY_PARAMS_TEST = {
+        :quiet => ENV['HYDRA_CONSOLE'] ? false : true,
+        :jetty_home => JETTY_HOME_TEST,
+        :jetty_port => 8983,
+        :solr_home => File.expand_path(JETTY_HOME_TEST + '/solr'),
+        :fedora_home => File.expand_path(JETTY_HOME_TEST + '/fedora/default')
+      }
+
+      JETTY_PARAMS_DEV = {
+        :quiet => ENV['HYDRA_CONSOLE'] ? false : true,
+        :jetty_home => JETTY_HOME_DEV,
+        :jetty_port => 8984,
+        :solr_home => File.expand_path(JETTY_HOME_DEV + '/solr'),
+        :fedora_home => File.expand_path(JETTY_HOME_DEV + '/fedora/default')
+      }
+      
+      # If Fedora Repository connection is not already initialized, initialize it using ActiveFedora defaults
+      ActiveFedora.init unless Thread.current[:repo]  
+    end
+
+    desc "Copies the default SOLR config for the bundled jetty"
+    task :config_solr => [:init] do
+      FileList['solr/conf/*'].each do |f|  
+        cp("#{f}", JETTY_PARAMS_TEST[:solr_home] + '/conf/', :verbose => true)
+        cp("#{f}", JETTY_PARAMS_DEV[:solr_home] + '/conf/', :verbose => true)
+      end
+    end
+    
+    desc "Copies a custom fedora config for the bundled jetty"
+    task :config_fedora => [:init] do
+      fcfg = 'fedora/conf/fedora.fcfg'
+      if File.exists?(fcfg)
+        puts "copying over fedora.fcfg"
+        cp("#{fcfg}", JETTY_PARAMS_TEST[:fedora_home] + '/server/config/', :verbose => true)
+        cp("#{fcfg}", JETTY_PARAMS_DEV[:fedora_home] + '/server/config/', :verbose => true)
+      else
+        puts "#{fcfg} file not found -- skipping fedora config"
+      end
+    end
+    
+    desc "Copies the default Solr & Fedora configs into the bundled jetty"
+    task :config do
+      Rake::Task["hydra:jetty:config_fedora"].invoke
+      Rake::Task["hydra:jetty:config_solr"].invoke
+    end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: jettywrapper
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Bess Sadler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-22 00:00:00 -07:00
+date: 2011-06-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -223,12 +223,14 @@ files:
 - Gemfile
 - README.textile
 - Rakefile
+- TODO.txt
 - jettywrapper.gemspec
 - lib/jettywrapper.rb
 - lib/jettywrapper/version.rb
-- spec/lib/jettywrapper_integration_spec.rb
+- spec/lib/jettywrapper_integration_spec.run_by_hand
 - spec/lib/jettywrapper_spec.rb
 - spec/spec_helper.rb
+- tasks/jettywrapper.rake
 has_rdoc: true
 homepage: https://github.com/projecthydra/jettywrapper
 licenses: []

data/spec/lib/jettywrapper_integration_spec.rb

@@ -1,59 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-require File.join(File.dirname(__FILE__), "/../../lib/jettywrapper")
-require 'rubygems'
-require 'ruby-debug'
-require 'uri'
-
-module Hydra
-  describe Jettywrapper do    
-    context "integration" do
-      before(:all) do
-        $stderr.reopen("/dev/null", "w")
-      end
-      
-      it "starts" do
-        
-        jetty_params = {
-          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1")
-        
-        }
-        Jettywrapper.configure(jetty_params) 
-        ts = Jettywrapper.instance
-        ts.logger.debug "Stopping jetty from rspec."
-        ts.stop
-        ts.start      
-        ts.logger.debug "Jetty started from rspec at #{ts.pid}"
-        pid_from_file = File.open( ts.pid_path ) { |f| f.gets.to_i }
-        ts.pid.should eql(pid_from_file)
-        sleep 15 # give jetty time to start
-      
-        # Can we connect to solr?
-        require 'net/http' 
-        response = Net::HTTP.get_response(URI.parse("http://localhost:8888/solr/admin/"))
-        response.code.should eql("200")
-        ts.stop
-      
-      end
-      
-      it "won't start if it's already running" do
-        jetty_params = {
-          :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty1")
-        
-        }
-        Jettywrapper.configure(jetty_params) 
-        ts = Jettywrapper.instance
-        ts.logger.debug "Stopping jetty from rspec."
-        ts.stop
-        ts.start
-        sleep 15
-        ts.logger.debug "Jetty started from rspec at #{ts.pid}"
-        response = Net::HTTP.get_response(URI.parse("http://localhost:8888/solr/admin/"))
-        response.code.should eql("200")
-        lambda { ts.start }.should raise_exception(/Server is already running/)
-        ts.stop
-      end
-      
-    end
-    
-  end
-end