mizuno-aspace 9.4.44

data/lib/mizuno/runner.rb

@@ -0,0 +1,292 @@
+require 'ffi'
+require 'net/http'
+require 'choice'
+require 'childprocess'
+require 'fileutils'
+require 'etc'
+require 'rack'
+require 'mizuno'
+require 'mizuno/choices'
+require 'mizuno/server'
+require 'rack/handler/mizuno'
+
+module Mizuno
+    require 'rbconfig'
+
+    module Daemonizer
+        def self.included?(base)
+            if(Config::CONFIG['host_os'] =~ /mswin|mingw/)
+                base.send(:extend, StubbedClassMethods)
+            else
+                base.send(:extend, UnixClassMethods)
+                base.send(:class_eval) do
+                    extend FFI::Library
+                    ffi_lib 'c'
+                    attach_function :_setuid, :setuid, [ :uint ], :int
+                    attach_function :_setgid, :setgid, [ :uint ], :int
+                end
+            end
+
+        end
+
+        module UnixClassMethods
+            #
+            # Switch the process over to a new user id; will abort the
+            # process if it fails. _options_ is the full list of options
+            # passed to a server.
+            #
+            def setuid(options)
+                entry = Etc.getpwnam(options[:user])
+                die("Can't find --user named '#{options[:user]}'") \
+                    unless entry
+                return unless (_setuid(entry.uid) != 0)
+                die("Can't switch to user '#{options[:user]}'")
+            end
+
+            #
+            # Like setuid, but for groups.
+            #
+            def setgid(options)
+                entry = Etc.getgrnam(options[:group])
+                die("Can't find --group named '#{options[:group]}'") \
+                    unless entry
+                return unless (_setgid(entry.gid) != 0)
+                die("Can't switch to group '#{options[:group]}'")
+            end
+        end
+
+        module StubbedClassMethods
+            def setuid(options)
+            end
+
+            def setgid(options)
+            end
+        end
+    end
+
+    #
+    # Launches Mizuno when called from the command-line, and handles
+    # damonization via FFI.
+    #
+    # Daemonization code based on Spoon.
+    #
+    class Runner
+        include Daemonizer
+
+        #
+        # Launch Jetty, optionally as a daemon.
+        #
+        def Runner.start!
+            # Default rackup is in config.ru
+            config = (Choice.rest.first or "config.ru")
+
+            # Create an options hash with only symbols.
+            choices = Choice.choices.merge(:config => config)
+            options = Hash[choices.map { |k, v| [ k.to_sym, v ] }]
+
+            # Resolve relative paths to the logfile, etc.
+            root = options[:root]
+            options[:pidfile] = Runner.resolve_path(root, options[:pidfile])
+            options[:log] = Runner.resolve_path(root, options[:log])
+            options[:public] = Runner.resolve_path(root, options[:public])
+
+            # Require multiple libraries.
+            options.delete(:require).each { |r| require r }
+
+            # Handle daemon-related commands.
+            Runner.status(options) if options.delete(:status)
+            Runner.reload(options) if options.delete(:reload)
+            Runner.stop(options) if options.delete(:stop)
+            Runner.kill(options) if options.delete(:kill)
+            Runner.daemonize(options) if options.delete(:daemonize)
+
+            # Fire up Mizuno as if it was called from Rackup.
+            Runner.start(options)
+        end
+
+        def Runner.start(options)
+            Dir.chdir(options[:root])
+            Logger.configure(options)
+            ENV['RACK_ENV'] = options[:env]
+            server = Rack::Server.new
+            server.options = options.merge(:server => 'mizuno',
+                :environment => options[:env])
+            server.start
+        end
+
+        #
+        # Relaunch as a daemon.
+        #
+        def Runner.daemonize(options)
+            # Ensure that Mizuno isn't running.
+            Runner.pid(options) and die("Mizuno is already running.")
+
+            # Build a command line that should launch JRuby with the
+            # appropriate options; this depends on the proper jruby
+            # being in the $PATH
+            config = options.delete(:config)
+            args = Mizuno::LAUNCH_ENV.concat(options.map { |k, v| 
+                (v.to_s.empty?) ? nil : [ "--#{k}", v.to_s ] }.compact.flatten)
+            args.push(config)
+            args.unshift('jruby')
+
+            # Launch a detached child process.
+            child = ChildProcess.build(*args)
+            child.io.inherit!
+            child.detach = true
+            child.start
+            File.open(options[:pidfile], 'w') { |f| f.puts(child.pid) }
+
+            # Wait until the server starts or we time out waiting for it.
+            exit if wait_for_server(options, 60)
+            child.stop
+            die("Failed to start Mizuno.")
+        end
+
+        #
+        # Return the status of a running daemon.
+        #
+        def Runner.status(options)
+            die("Mizuno doesn't appear to be running.") \
+                unless (pid = Runner.pid(options))
+            die("Mizuno is running, but not online.") \
+                unless(wait_for_server(options))
+            die("Mizuno is running.", true)
+        end
+
+        #
+        # Reload a running daemon by SIGHUPing it.
+        #
+        def Runner.reload(options)
+            pid = Runner.pid(options)
+            return(Runner.daemonize(options)) \
+                if(pid.nil? and options.delete(:restart))
+            die("Mizuno is currently not running.") unless pid
+            Process.kill("HUP", pid)
+            die("Mizuno signaled to reload app.", true)
+        end
+
+        #
+        # Stop a running daemon (SIGKILL)
+        #
+        def Runner.stop(options)
+            pid = Runner.pid(options) or die("Mizuno isn't running.")
+            print "Stopping Mizuno..."
+            Process.kill("KILL", pid)
+            die("failed") unless wait_for_server_to_die(options)
+            FileUtils.rm(options[:pidfile])
+            die("stopped", true)
+        end
+
+        #
+        # Really stop a running daemon (SIGTERM)
+        #
+        def Runner.kill(options)
+            pid = Runner.pid(options) or die("Mizuno isn't running.")
+            $stderr.puts "Terminating Mizuno with extreme prejudice..."
+            Process.kill("TERM", pid)
+            die("failed") unless wait_for_server_to_die(options)
+            FileUtils.rm(options[:pidfile])
+            die("stopped", true)
+        end
+
+        #
+        # Transform a relative path to an absolute path.
+        #
+        def Runner.resolve_path(root, path)
+            return(path) unless path.is_a?(String)
+            return(path) if (path =~ /^\//)
+            File.expand_path(File.join(root, path))
+        end
+
+        #
+        # Fetches the PID from the :pidfile.
+        #
+        def Runner.pid(options)
+            options[:pidfile] or die("Speficy a --pidfile to daemonize.") 
+            return unless File.exists?(options[:pidfile])
+            pid = File.read(options[:pidfile]).to_i
+
+            # FIXME: This is a hacky way to get the process list, but I
+            # haven't found a good cross-platform solution yet; this
+            # should work on MacOS and Linux, possibly Solaris and BSD,
+            # and almost definitely not on Windows.
+            process = `ps ax`.lines.select { |l| l =~ /^\s*#{pid}\s*/ }
+            return(pid) if (process.join =~ /\bmizuno\b/)
+
+            # Stale pidfile; remove.
+            $stderr.puts("Removing stale pidfile '#{options[:pidfile]}'")
+            FileUtils.rm(options[:pidfile])
+            return(nil)
+        end
+
+        #
+        # Wait until _timeout_ seconds for a successful http connection;
+        # returns true if we could connect and didn't get a server
+        # error, false otherwise.
+        #
+        def Runner.wait_for_server(options, timeout = 120)
+            force_time_out_at = Time.now + timeout
+            sleep_interval_for_next_retry = 0.1
+
+            begin
+                response = connect_to_server_as_client(options, timeout)
+                return(response.code.to_i < 500)
+            rescue Errno::ECONNREFUSED => error
+                return(false) if (Time.now > force_time_out_at)
+                sleep(sleep_interval_for_next_retry)
+                sleep_interval_for_next_retry *= 2
+                retry
+            rescue => error
+                puts "HTTP Error '#{error}'"
+                return(false)
+            end
+        end
+
+        #
+        # Like wait_for_server, but returns true when the server goes
+        # offline. If we hit _timeout_ seconds and the server is still
+        # responding, returns false.
+        #
+        def Runner.wait_for_server_to_die(options, timeout = 120)
+            force_time_out_at = Time.now + timeout
+            sleep_interval_for_next_retry = 0.1
+
+            begin
+                while (Time.now < force_time_out_at)
+                    connect_to_server_as_client(options, timeout)
+                    sleep(sleep_interval_for_next_retry)
+                    sleep_interval_for_next_retry *= 2
+                end
+                return(false)
+            rescue Errno::ECONNREFUSED => error
+                return(true)
+            rescue => error
+                puts "**** http error: #{error}"
+                return(true)
+            end
+        end
+
+        def Runner.connect_to_server_as_client(server_options, timeout)
+            options = server_options.dup
+            options[:host] = '127.0.0.1' if options[:host] == "0.0.0.0"
+            Net::HTTP.start(options[:host], options[:port]) do |http|
+                http.read_timeout = timeout
+                http.get("/")
+            end
+        end
+
+        #
+        # Exit with a message and a status value.
+        #
+        # FIXME: Dump these in the logfile if called from Server?
+        #
+        def Runner.die(message, success = false)
+            $stderr.puts(message)
+            exit(success ? 0 : 1)
+        end
+    end
+end
+
+# Ensure that we shutdown the server on exit.
+at_exit { Mizuno::Server.stop }

data/lib/mizuno/server.rb

@@ -0,0 +1,167 @@
+# FIXME: mizuno/http_server needs to still work, but we will throw out a
+# deprecation notice and remove it in later versions.
+
+require 'rack'
+require 'rack/rewindable_input'
+require 'mizuno'
+Mizuno.require_jars(%w(jetty-continuation jetty-http jetty-io jetty-jmx
+    jetty-security jetty-server jetty-util servlet-api
+    rewindable-input-stream))
+require 'mizuno/version'
+require 'mizuno/rack/chunked'
+require 'mizuno/rack_handler'
+#require 'mizuno/logger'
+require 'mizuno/reloader'
+
+module Mizuno
+    class Server
+        java_import 'org.eclipse.jetty.server.nio.NetworkTrafficSelectChannelConnector'
+        java_import 'org.eclipse.jetty.util.thread.QueuedThreadPool'
+        java_import 'org.jruby.rack.servlet.RewindableInputStream'
+
+        # java_import "org.eclipse.jetty.server.ssl.SslSelectChannelConnector"
+
+        # attr_accessor :logger
+
+        @lock ||= Mutex.new
+
+        def Server.run(app, options = {})
+            @lock.synchronize do
+                return if @server
+                @server = new
+                @server.run(app, options)
+            end
+        end
+
+        def Server.stop
+            @lock.synchronize do
+                return unless @server
+                @server.stop
+                @server = nil
+            end
+        end
+
+        def Server.logger
+            Logger.logger
+        end
+
+        #
+        # Start up an instance of Jetty, running a Rack application.
+        # Options can be any of the follwing, and are not
+        # case-sensitive:
+        #
+        # :host::
+        #     String specifying the IP address to bind to; defaults
+        #     to 0.0.0.0.
+        #
+        # :port::
+        #     String or integer with the port to bind to; defaults
+        #     to 9292.
+        #
+        def run(app, options = {})
+            # Symbolize and downcase keys.
+            @options = options = Hash[options.map { |k, v|
+                [ k.to_s.downcase.to_sym, v ] }]
+            options[:quiet] ||= true if options[:embedded]
+
+            # Thread pool
+            threads = options[:threads] || 50
+            thread_pool = QueuedThreadPool.new
+            thread_pool.min_threads = options.fetch(:min_threads,
+                                                    [ threads.to_i / 10, 5 ].max)
+            thread_pool.max_threads = [ threads.to_i, 10 ].max
+
+            # The Jetty server
+            # Logger.configure(options)
+            # @logger = Logger.logger
+            @server = Java.org.eclipse.jetty.server.Server.new(thread_pool)
+#            @server.setSendServerVersion(false)
+
+#            @server.set_thread_pool(thread_pool)
+
+            # Connector
+            connector = Java.org.eclipse.jetty.server.ServerConnector.new(@server)
+            connector.setReuseAddress(options.fetch(:reuse_address, false))
+            connector.setPort(options[:port].to_i)
+            connector.setHost(options[:host])
+            # max_header_size = options.fetch(:max_header_size, 32768)
+            # connector.setRequestHeaderSize(max_header_size)
+
+            @server.addConnector(connector)
+
+            # SSL Connector
+            #configure_https(options) if options[:ssl_port]
+
+            # Switch to a different user or group if we were asked to.
+            Runner.setgid(options) if options[:group]
+            Runner.setuid(options) if options[:user]
+
+            # Optionally wrap with Mizuno::Reloader.
+            threshold = (ENV['RACK_ENV'] == 'production' ? 10 : 1)
+            app = Mizuno::Reloader.new(app, threshold) \
+                if options[:reloadable]
+
+            # The servlet itself.
+            rack_handler = RackHandler.new(self)
+            rack_handler.rackup(app)
+
+            # Add the context to the server and start.
+            @server.set_handler(rack_handler)
+            @server.start
+            $stderr.printf("%s listening on %s:%s\n", version,
+                connector.host, connector.port) unless options[:quiet]
+
+            # If we're embedded, we're done.
+            return if options[:embedded]
+
+            # Stop the server when we get The Signal.
+            trap("SIGTERM") { @server.stop and exit }
+
+            # Join with the server thread, so that currently open file
+            # descriptors don't get closed by accident.
+            # http://www.ruby-forum.com/topic/209252
+            @server.join
+        end
+
+        #
+        # Shuts down an embedded Jetty instance.
+        #
+        def stop
+            return unless @server
+            $stderr.print "Stopping Jetty..." unless @options[:quiet]
+            @server.stop
+            $stderr.puts "done." unless @options[:quiet]
+        end
+
+        #
+        # Returns the full version string.
+        #
+        def version
+            "Mizuno #{Mizuno::VERSION} (Jetty #{Java.org.eclipse.jetty.server.Server.getVersion})"
+        end
+
+        #
+        # Wraps the Java InputStream for the level of Rack compliance
+        # desired.
+        #
+        def rewindable(request)
+            input = request.getInputStream
+
+            @options[:rewindable] ?
+                Rack::RewindableInput.new(input.to_io.binmode) :
+                RewindableInputStream.new(input).to_io.binmode
+        end
+
+        private
+
+        # def configure_https(options)
+        #     connector = SslSelectChannelConnector.new
+        #     connector.setPort(options[:ssl_port])
+        #     factory = connector.getSslContextFactory
+        #     factory.setKeyStore(options[:keystore] || "keystore")
+        #     factory.setKeyStorePassword(options[:keystore_password])
+        #     @server.addConnector(connector)
+        #     self
+        # end
+    end
+end

data/lib/mizuno/version.rb

@@ -0,0 +1,3 @@
+module Mizuno
+    VERSION = "9.4.44"
+end

data/lib/mizuno.rb

@@ -0,0 +1,39 @@
+#
+# A Rack handler for Jetty 8.
+#
+# Written by Don Werve <don@madwombat.com>
+#
+
+require 'java'
+
+# Save our launch environment for spawning children later.
+module Mizuno
+    LAUNCH_ENV = $LOAD_PATH.map { |i| "-I#{i}" }.push($0)
+
+    HOME = File.expand_path(File.dirname(__FILE__))
+
+    #
+    # Tell log4j not to complain to the console about a missing
+    # log4j.properties file, as we configure it programmatically in
+    # Mizuno::Server (http://stackoverflow.com/questions/6849887)
+    #
+    # def Mizuno.initialize_logger
+    #     require_jars(%w(log4j slf4j-api slf4j-log4j12))
+    #     Java.org.apache.log4j.Logger.getRootLogger.setLevel( \
+    #         Java.org.apache.log4j.Level::INFO)
+    # end
+
+    #
+    # Loads jarfiles independent of versions.
+    #
+    def Mizuno.require_jars(*names)
+        names.flatten.each do |name|
+            file = Dir[File.join(HOME, 'java', "#{name}-*.jar")].first
+            file ||= Dir[File.join(HOME, 'java', "#{name}.jar")].first
+            raise("Unknown or missing jar: #{name}") unless file
+            require file
+        end
+    end
+end
+
+#Mizuno.initialize_logger

data/lib/rack/handler/mizuno.rb

@@ -0,0 +1,4 @@
+require 'mizuno/server'
+
+# Register ourselves with Rack when this file gets loaded.
+Rack::Handler.register 'mizuno', 'Mizuno::Server'

data/mizuno.gemspec

@@ -0,0 +1,39 @@
+$:.push File.expand_path("../lib/mizuno", __FILE__)
+require 'version'
+
+Gem::Specification.new do |spec|
+    spec.name = "mizuno-aspace"
+    spec.version = Mizuno::VERSION
+    spec.required_rubygems_version = Gem::Requirement.new(">= 1.2") \
+        if spec.respond_to?(:required_rubygems_version=)
+    spec.authors = [ "Don Werve", "ArchivesSpace Program Team" ]
+    spec.description = 'Jetty-powered running shoes for JRuby/Rack.'
+    spec.summary = 'Rack handler for Jetty 8 on JRuby. Features multithreading, event-driven I/O, and async support.'
+    spec.email = 'ArchivesSpaceHome@lyrasis.org'
+    spec.executables = [ "mizuno" ]
+    # FIXME: Use Dir.glob for this
+    spec.files = %w(.gitignore
+        README.markdown
+        LICENSE
+        Rakefile
+        Gemfile
+        mizuno.gemspec)
+    spec.files.concat(Dir['lib/**/*.rb'])
+    spec.files.concat(Dir['bin/*'])
+    spec.files.concat(Dir['lib/**/*.jar'])
+#    jars = Dir.entries("lib/java").grep(/\.jar$/)
+#    spec.files.concat(jars.map { |j| "lib/java/#{j}" })
+    spec.homepage = 'http://github.com/archivesspace/mizuno'
+    spec.has_rdoc = false
+    spec.require_paths = [ "lib" ]
+    spec.rubygems_version = '1.3.6'
+    spec.add_dependency('rack', '>= 1.0.0')
+    spec.add_dependency('ffi', '>= 1.0.0')
+    spec.add_dependency('choice', '>= 0.1.0')
+    spec.add_dependency('childprocess', '>= 0.2.6')
+    spec.add_development_dependency('rake')
+    spec.add_development_dependency('rspec', '>= 2.7.0')
+    spec.add_development_dependency('rspec-core', '>= 2.7.0')
+    spec.add_development_dependency('json_pure', '>= 1.6.0')
+    spec.add_development_dependency('nokogiri')
+end