glassfish 0.9.5-universal-java → 1.0.0-universal-java

data/README.txt

@@ -0,0 +1,140 @@
+= GlassFish v3 server for Rack based web frameworks (Rails, Merb, ...)
+
+GlassFish gem is a lightweight and robust deployment solution for
+Ruby on Rails applications deployed on JRuby runtime. It is based
+on GlassFish v3 application server.
+
+GlassFish v3 is a Java based application server that allows deployment, 
+administration and monitoring of JavaEE as well as dynamic languages based web 
+frameworks such as Ruby On Rails, Grails etc.
+
+GlassFish gem is based on GlassFish v3 nucleus. GlassFish v3 nucleus is the core module of GlassFish v3.
+
+For more information on GlassFish v3 application server see GlassFish project page[https://glassfish.dev.java.net/].
+
+== Requires JDK 6
+Get JDK 6 from here[http://java.sun.com/javase/downloads/index.jsp]
+
+== Supported Rack based frameworks
+
+* Rails
+* Merb
+* Sinatra
+
+=== Getting Started
+
+1. Install the gem: <tt>gem install glassfish</tt>.
+2. Run glassfish in the top directory of your Rails or Merb application: 
+	
+	$glassfish
+
+=== Usage
+
+GlassFish gem's +glassfish+ command autodetects the application you trying to 
+run on it. Internally it uses Grizzly handler to plugin to Rack interface of 
+the application frameworks such as Rails, Merb or Sinatra.
+
+    $ glassfish
+
+That's all you need to run your application.
+
+    $glassfish -h
+
+===Synopsis
+	
+	glassfish: GlassFish v3 server for Rack based frameworks such as: Rails,
+	Merb, Sinatra...
+
+===Usage:
+	
+	glassfish [OPTION] APPLICATION_PATH
+
+	-h, --help:             show help
+
+	-c, --contextroot PATH: change the context root (default: '/')
+
+	-p, --port PORT:        change server port (default: 3000)
+	
+	-a, --address HOST:     bind to HOST address (default: 0.0.0.0)
+
+	-e, --environment ENV:  change rails environment (default: development)
+
+	-n --runtimes NUMBER:   Number of JRuby runtimes to create initially
+
+	--runtimes-min NUMBER:  Minimum JRuby runtimes to create
+
+	--runtimes-max NUMBER:  Maximum number of JRuby runtimes to create
+
+	-d, --daemon:           Run GlassFish as daemon. Currently works with
+	                        Linux and Solaris OS.
+
+	-P, --pid FILE:         PID file where PID will be written. Applicable
+	                        when used with -d option. The default pid file
+	                        is tmp/pids/glassfish-<PID>.pid
+
+	-l, --log FILE:         Log file, where the server log messages will go.
+	                        By default the server logs go to
+	                        log/development.log file. To see the logs on
+	                        console run with -l option without any argument.
+
+	--log-level LEVEL:      Log level 0 to 7. 0:OFF, 1:SEVERE, 2:WARNING,
+	                        3:INFO (default), 4:FINE, 5:FINER, 6:FINEST,
+	                        7:ALL.
+
+	--config FILE:          Configuration file location. Use glassfish.yml
+	                        as template. Generate it using 'gfrake config'
+	                        command.
+
+	APPLICATION_PATH (optional): Path to the application to be run (default:
+	current).
+
+	For further configuration, run GlassFish rake command 'gfrake -T'
+	
+===Configuration
+
+	$gfrake -T
+	
+	rake clean    # Clean GlassFish generated temporary files (tmp/.glassfish)
+	rake config   # Generate a configuration file to customize GlassFish gem
+	rake version  # Display version of GlassFish gem
+	
+<b>Note:</b> Although help screen shows rake command. You need to use gfrake instead.
+
+* <tt>gfrake config</tt> will place <b>glassfish.yml</b> in the application's config directory. <b>glassfish.yml</b> contains default options. Use it as template. You can also use <tt>--config</tt> option with the <tt>glassfish</tt> command	
+
+=== Application auto-detection
+
+Rails, Merb and Sinatra applications are detected automatically and configured appropriately. You can provide a rack-up script <tt>*.ru</tt> in to the application directory to plugin any other framework.
+
+Some key points:
+
+* Rails version < 2.2 is single threaded, for improved scaling you can  
+  configure the JRuby runtime pool using <tt>--runtimes, --runtimes-min or 
+  --runtimes-max</tt> options.
+* Multi-thread-safe execution (as introduced in Rails 2.2 or for Merb) is 
+  detected and runtime pooling is disabled. You would still need to tell Rails 
+  to enable multi-threading by commenting out the following line from 
+  <tt>config/environments/production.rb</tt>.
+  
+  <tt>#config.threadsafe!</tt>
+  
+  Or you can simply call config.threadsafe! form any Rails initialization 
+  script.
+
+=== Known Issues
+
+* Running <tt>glassfish</tt> in a directory that is neither a Rails or Merb
+  application does not report a meaningful error.
+  See this issue[https://glassfish.dev.java.net/issues/show_bug.cgi?id=6744]
+
+
+=== Source
+
+You can get the GlassFish source using svn, in any of the following ways:
+
+<tt>svn co https://svn.dev.java.net/svn/glassfish-scripting/trunk/rails/gem</tt>
+
+=== License
+
+GlassFish v3 gem is provided with CDDL 1.0 and GPL 2.0 dual license. For 
+details see https://glassfish.dev.java.net/public/CDDL+GPL.html.

data/bin/gfrake

@@ -48,7 +48,11 @@ application.standard_exception_handling do
       puts "(file #{GlassFish::Config::FILE} already exists. Pass argument FORCE=1 to override)"
     elsif !File.directory?("config")
       puts "(directory 'config' is missing)"
-    else	
+    else
+      if File.exists?(GlassFish::Config::FILE) #FORCE=1
+        puts "(Backing up #{GlassFish::Config::FILE}.)"
+        cp GlassFish::Config::FILE, GlassFish::Config::FILE+".bak"
+      end
       cp "#{GlassFish::HOME}/generators/gfrake/templates/glassfish.yml", GlassFish::Config::FILE
     end
   end

data/bin/glassfish

@@ -15,6 +15,9 @@
  # -p, --port PORT::
  #    change server port (default: 3000)
  #
+ # -a, --address HOST::
+ #    bind to HOST address (default: 0.0.0.0)
+ #
  # -e, --environment ENV::
  #    change rails environment (default: development)
  #
@@ -46,13 +49,8 @@
  #
  # For further configuration, run GlassFish rake command 'gfrake -T'
 
- require "java"
- $LOAD_PATH << "#{File.dirname(__FILE__)}/../modules"
- $LOAD_PATH << "#{File.dirname(__FILE__)}/../lib"
-
- require 'command_line_parser'
  require 'glassfish'
 
  options = GlassFish::CommandLineParser.new.parse
- gf = GlassFish::Server.new
- gf.startup(options)
+ GlassFish::Server.start options
+

data/generators/gfrake/templates/glassfish.yml

@@ -13,10 +13,49 @@ http:
 
     # port
     port: 3000
+    
+    #address
+    address: 0.0.0.0
 
     # context root. The default value is '/'
     contextroot: /
 
+    # Grizzly is NIO based HTTP libraries used by GlassFish gem
+    grizzly:
+        #HTTP chunking enable/disable
+        chunking-enabled: true
+
+        # Time after which the request times out in seconds
+        request-timeout: 30
+        
+        #Send buffer size
+        send-buffer-size: 8192
+        
+        #maximum number of keep-alive connections
+        max-keepalive-connextions: 256
+        
+        #Keep Alive timeout, max time a connection can be deemed as idle and kept
+        #in the keep-alive state
+        keepalive-timeout: 30
+                        
+        #http thread pool used by Grizzly
+        thread-pool:
+            #Idle threads are removed from pool, after this time (in seconds)
+            idle-thread-timeout-seconds: 900
+
+            #The maxim number of tasks, which could be queued on the thread pool.
+            #-1 disables any maximum checks.
+            max-queue-size: 4096
+
+            #Maximum number of threads in the threadpool servicing
+            #requests in this queue. This is the upper bound on the no. of
+            #threads that exist in the threadpool.
+            max-thread-pool-size: 5
+
+            #Minimum number of threads in the threadpool servicing
+            #requests in this queue. These are created up front when this
+            #threadpool is instantiated
+            min-thread-pool-size: 2                
 
 #Logging configuration
 log:

data/lib/command_line_parser.rb

@@ -45,33 +45,18 @@ require 'java'
 #
 module GlassFish
   class CommandLineParser
+    attr_accessor :config
 
-    def init_opts    
-      @@config ||= {
-        :runtimes     => 1,
-        :runtimes_min => 1,
-        :runtimes_max => 1,
-        :contextroot  => '/',
-        :environment  => "development",
-        :app_dir      => Dir.pwd,
-        :port         => 3000,
-        :pid          => nil,
-        :log          => nil,
-        :log_console  => false,
-        :log_level    => 3,
-        :daemon       => false,
-        :jvm_options  => nil
-      }
-    end
 
     def parse
-      
+
       check_java
 
-      config = init_opts            
-      
+      @config = Config.init_opts
+
       opts = GetoptLong.new(
       [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--address', '-a', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--environment', '-e', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--contextroot', '-c', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--config', GetoptLong::REQUIRED_ARGUMENT ],
@@ -86,7 +71,7 @@ module GlassFish
       [ '--help', '-h', GetoptLong::NO_ARGUMENT ]
       )
 
-      config_file = File.join(config[:app_dir], "config", "glassfish.yml") 
+      config_file = File.join(config[:app_dir], "config", "glassfish.yml")
       opts.each do |opt, arg|
         case opt
         when '--version'
@@ -97,6 +82,8 @@ module GlassFish
           RDoc::usage
         when '--contextroot'
           config[:contextroot] = arg
+        when '--address'
+          config[:address] = arg
         when '--port'
           config[:port] = arg.to_i
         when '--environment'
@@ -127,21 +114,18 @@ module GlassFish
 
 
       config[:app_dir] = ARGV.shift unless ARGV.empty?
-            
+
       #Read the config file from config/glasfish.yml
       config_file = Config::absolutize config[:app_dir],config_file
       read_glassfish_config(config_file, config)
 
-      #Validate the command line options
-      Config.new.validate config
-            
       config
 
     end
 
     private
 
-    # Read glassfish config file from config/glassfish.yml. CLI options will 
+    # Read glassfish config file from config/glassfish.yml. CLI options will
     # override the glassfish.yml configurations
     def read_glassfish_config(cfile, config)
 
@@ -157,15 +141,20 @@ module GlassFish
         case opt
         when 'http'
           val = arg['port']
-          if(!val.nil?)
-            config[:port] = val.to_i
-          end
+          config[:port] = val.to_i unless val.nil?
+
+          val = arg['address']
+          config[:address] = val unless val.nil?
 
           val = arg['contextroot']
           config[:contextroot] = val unless val.nil?
-        when 'log'          
+
+
+          config[:grizzly_config] = arg['grizzly'] unless arg['grizzly'].nil?
+
+        when 'log'
           val = arg['log-file']
-          if(!val.nil?)
+          unless val.nil?
             config[:log] = Config::absolutize config[:app_dir], val
           end
 
@@ -175,7 +164,7 @@ module GlassFish
           config[:runtimes] = arg['initial'] unless arg['initial'].nil?
           config[:runtimes_min] = arg['min'] unless arg['min'].nil?
           config[:runtimes_max] = arg['max'] unless arg['max'].nil?
-        when 'daemon'          
+        when 'daemon'
           config[:daemon] = arg['enable'] unless arg['enable'].nil?
           if(!arg['pid'].nil?)
             if(!config[:daemon])
@@ -184,23 +173,23 @@ module GlassFish
               config[:pid] = File.expand_path arg['pid']
             end
           end
-          
+
           #CLI option are overriden by glassfish.yml settings
           if(!data['daemon'].nil? and (data['daemon'] or config[:daemon]))
-            config[:jvm_options] = arg['jvm-options'] unless  arg['jvm-options'].nil?         
+            config[:jvm_options] = arg['jvm-options'] unless  arg['jvm-options'].nil?
           else
             STDERR.puts "Ignoring JVM options #{arg}. JVM options can only be passed in daemon mode. To use these, enable daemon mode"
-          end          
+          end
         when 'environment'
           config[:environment] = arg unless arg.nil?
-        end      
-      end 
-    end      
+        end
+      end
+    end
 
     def check_java
-      begin 
+      begin
           java.lang.Class.forName("javax.xml.ws.Service")
-      rescue 
+      rescue
           #It is not Java6, fail
           STDERR.puts "ERROR: You are running, Java version: "+java.lang.System.getProperty("java.version")+"."
           STDERR.puts "ERROR: GlassFish gem needs Java ver. 6.0 or higher!"

data/lib/config.rb

@@ -45,17 +45,37 @@ module GlassFish
     PID_FILE = Dir.pwd+File::SEPARATOR+"tmp"+File::SEPARATOR+"pids"+File::SEPARATOR+"glassfish"
     DEFAULT_JVM_OPTS = "-server -Xmx512m -XX:MaxPermSize=192m -XX:NewRatio=2 -XX:+DisableExplicitGC -Dhk2.file.directory.changeIntervalTimer=6000";
 
-    # Validates the configuration options. If it can will revert to default else 
-    # fail 
-    def validate config
+    def self.init_opts
+      {
+        :runtimes     => 1,
+        :runtimes_min => 1,
+        :runtimes_max => 1,
+        :contextroot  => '/',
+        :environment  => "development",
+        :app_dir      => Dir.pwd,
+        :port         => 3000,
+        :address      => "0.0.0.0",
+        :pid          => nil,
+        :log          => nil,
+        :log_console  => false,
+        :log_level    => 3,
+        :daemon       => false,
+        :jvm_options  => nil        
+      }
+    end
+
+
+    # Validates the configuration options. If it can will revert to default else
+    # fail
+    def validate! config
       # http configuration
       # port
       begin
-        server = TCPServer.new '0.0.0.0', config[:port]
-      rescue 
-        STDERR.puts "0.0.0.0:#{config[:port]}: " + $!      
+        server = TCPServer.new config[:port]
+      rescue
+        STDERR.puts "#{config[:address]}:#{config[:port]}: " + $!
         #TODO: we should give an option of ephemeral port support
-        exit(1) 
+        exit(1)
       end
       server.close
 
@@ -63,25 +83,25 @@ module GlassFish
       if(config[:daemon])
         os = java.lang.System.getProperty("os.name").downcase
         version = java.lang.System.getProperty("os.version")
-        #check the platform, Currently daemon mode works only on linux and 
+        #check the platform, Currently daemon mode works only on linux and
         #solaris
         if(!os.include?("linux") and !os.include?("sunos"))
           Config.fail "You are running on #{java.lang.System.getProperty("os.name")}  #{version}. Currently daemon mode only works on Linux or Solaris platforms!"
         end
-        
+
         # In daemon mode you can't log to console. Let's fail and let user spcifiy the log file explicitly
 	      if(config[:log_console])
 	        Config.fail "Daemon mode detected, console logging is disabled in daemon mode. You must provide path to log file with --log|-l option in daemon mode."
         end
-	      
-        
+
+
         if(config[:jvm_options].nil?)
           config[:jvm_options] = DEFAULT_JVM_OPTS
         end
         if(config[:pid].nil?)
           config[:pid] = PID_FILE
 	      end
-	      
+
         Config.absolutize config[:app_dir], config[:pid]
       end
 
@@ -91,6 +111,11 @@ module GlassFish
         Config.fail "\t0 OFF\n\t1 SEVERE \n\t2 WARNING\n\t3 INFO(default)\n\t4 FINE\n\t5 FINER\n\t6 FINEST\n\t7 ALL\n"
       end
 
+      if config[:runtimes] > config[:runtimes_max]
+        puts "Initial number of runtimes #{config[:runtimes]} is > max runtime #{config[:runtimes_max]}.\nIncreasing runtimes-max to #{config[:runtimes]}"
+        config[:runtimes_max] = config[:runtimes]
+      end
+
       # JRuby runtime
       runtimes_err = " Invalid runtime configuration, initial:#{config[:runtimes]}, min:#{config[:runtimes_min]}, max:#{config[:runtimes_max]}."
       err = false
@@ -133,7 +158,7 @@ module GlassFish
       end
 
 
-      # pid file 
+      # pid file
       #
       if(!config[:pid].nil? and !config[:daemon])
             GlassFish::Config::fail("--pid option can only be used with --daemon.")
@@ -145,12 +170,11 @@ module GlassFish
       domaindir = File.join(config[:app_dir], "tmp", ".glassfish")
       config[:domain_dir] = File.expand_path(domaindir)
 
-      if !setup_temp_domain?File.join(domaindir, "config")
-        puts "ERROR: Failed to create GlassFish domain directory: #{domaindir}"
+      if !check_domain_dir?domaindir
         exit -1
       end
     end
-    
+
     def self.fail(message)
       STDERR.puts "ERROR: #{message}"
       STDERR.puts "Type 'glassfish -h' to get help"
@@ -167,64 +191,34 @@ module GlassFish
       end
       path
     end
-    
+
 
     private
 
-    #
-    #Create a domain directory and copy the domain.xml and logging.properties 
-    #there. This will take care of infamous bug that causes people to run 
-    # glassfish gem as sudo if jruby is installed as root
-    #
-    def setup_temp_domain? config_dir
-      if !File.exist? config_dir
-        FileUtils.mkdir_p config_dir
+    def check_domain_dir?(domain_dir)
+      #create Glassfish domain directory if it does not exist
+      unless File.exist? domain_dir
+        File.makedirs(domain_dir)
+        return true
       end
 
-      #glassfish v3 preview release writes down the exact port number in domain.xml. to make
-      #it work, we need to update domain.xml and logging.properties everytime the app is run
-      same_version?config_dir
-      return check_domain_dir? config_dir
-    end
-
-    def check_domain_dir?(config_dir)
-      if !File.writable_real?config_dir
-        return false
+      config_dir = File.join(domain_dir, "config")
+      unless File.exist? config_dir
+        File.makedirs(config_dir)
+        return true
       end
-      src = File.dirname(__FILE__)+File::SEPARATOR+".."+File::SEPARATOR+"domains"+File::SEPARATOR+"domain1"+File::SEPARATOR+"config"
-      File.cp(File.join(src,"domain.xml"), config_dir)
-      File.cp(File.join(src,"logging.properties"), config_dir)
-      
-      #make sure both these files are writable
-      FileUtils.chmod(0755, File.join(config_dir,"domain.xml"))
-      FileUtils.chmod(0755, File.join(config_dir,"logging.properties"))
 
-    end
-
-    #
-    #Returns true if there is glasfish_gem_version.yml file and has the same 
-    #version as the glassfish gem. Otherwise creates a new file and returns 
-    #false so that rest of the stuff can be created
-    #
-    def same_version?(config_dir)
-      f = File.join(config_dir, 'glassfish_gem_version.yml')
-      if !File.exist? f
-        src = File.join(File.dirname(__FILE__), "..", "domains", "domain1", "config", "glassfish_gem_version.yml")
-        File.cp src, config_dir
+      if !File.writable_real?config_dir
+        puts "ERROR: GlassFish temporary directory: #{config_dir} not writable. Please give write permission to proceed."
         return false
       end
-      file = File.open(f)
-      data = YAML::load(file)
 
-      #this is probably corrupted, return false so that a new one can be placed
-      if not data.key?'glassfish'
-        return false; 
-      end
-      version = data['glassfish'].fetch('version', nil)
-      if(version.nil?)
-        return false
+      #glassfish gem <=0.9.5 created domain.xml, this causes latter version
+      #to fail so removing this as no more needed
+      if(File.exist?(config_dir) and File.exist?(File.join(config_dir, "domain.xml")))
+        FileUtils.rmtree config_dir
       end
-      version.eql?GlassFish::VERSION
+      true
     end
   end
 end