trinidad 1.3.5 → 1.4.0.RC

data/lib/trinidad/lifecycle/web_app/shared.rb

@@ -0,0 +1,53 @@
+module Trinidad
+  module Lifecycle
+    module WebApp
+      # Shared web application lifecycle hook, 
+      # does #configure before the context starts.
+      module Shared
+
+        attr_reader :web_app
+        alias_method :webapp, :web_app
+
+        def initialize(web_app)
+          @web_app = web_app
+        end
+
+        # @see Trinidad::Lifecycle::Base#before_start
+        def before_start(event)
+          super
+          configure(event.lifecycle)
+        end
+
+        # Configure the web application before it's started.
+        def configure(context)
+          remove_defaults(context)
+          configure_logging(context)
+        end
+
+        protected
+
+        def configure_logging(context)
+          Trinidad::Logging.configure_web_app(web_app, context)
+        end
+
+        private
+
+        def remove_defaults(context)
+          context.remove_welcome_file('index.jsp')
+          context.remove_welcome_file('index.htm')
+          context.remove_welcome_file('index.html')
+
+          jsp_servlet = context.find_child('jsp')
+          context.remove_child(jsp_servlet) if jsp_servlet
+
+          context.remove_servlet_mapping('*.jspx')
+          context.remove_servlet_mapping('*.jsp')
+
+          context.process_tlds = false
+          context.xml_validation = false
+        end
+        
+      end
+    end 
+  end
+end

data/lib/trinidad/lifecycle/web_app/war.rb

@@ -0,0 +1,52 @@
+module Trinidad
+  module Lifecycle
+    module WebApp
+      class War < Base
+        include Shared
+        
+        def before_start(event)
+          expand_war_app(event.lifecycle)
+          super # Shared#before_start
+        end
+        
+        def after_start(event)
+          super
+          remove_war_app(event.lifecycle)
+        end
+        
+        def configure(context)
+          super
+          configure_class_loader(context)
+        end
+
+        protected
+        
+        def configure_class_loader(context)
+          loader = Trinidad::Tomcat::WebappLoader.new(web_app.class_loader)
+          loader.container = context
+          context.loader = loader
+        end
+
+        private
+
+        def expand_war_app(context)
+          unless File.exist?(context.doc_base)
+            host = context.parent
+            war_file = java.io.File.new(web_app.web_app_dir)
+            war = java.net.URL.new("jar:" + war_file.toURI.toURL.to_s + "!/")
+            path_name = File.basename(context.doc_base)
+
+            Trinidad::Tomcat::ExpandWar.expand(host, war, path_name)
+          end
+        end
+        
+        def remove_war_app(context)
+          require 'fileutils'
+          FileUtils.rm_rf web_app.web_app_dir.gsub(/\.war$/, '')
+        end
+        
+      end
+    end
+    War = Trinidad::Lifecycle::WebApp::War # backwards compatibility
+  end
+end

data/lib/trinidad/logging.rb

@@ -0,0 +1,282 @@
+require 'jruby'
+require 'fileutils'
+
+module Trinidad
+  module Logging
+    
+    JUL = Java::JavaUtilLogging
+    LogFactory = Java::OrgApacheJuliLogging::LogFactory
+    
+    @@configured = nil
+    
+    # Configure the "global" Trinidad logging.
+    def self.configure(log_level = nil)
+      return false if @@configured
+      
+      root_logger = JUL::Logger.getLogger('')
+      level = parse_log_level(log_level, :INFO)
+
+      out_handler  = JUL::ConsoleHandler.new
+      out_handler.setOutputStream JRuby.runtime.out
+      out_handler.formatter = console_formatter
+
+      err_handler  = JUL::ConsoleHandler.new
+      err_handler.setOutputStream JRuby.runtime.err
+      err_handler.formatter = console_formatter
+      err_handler.level = level.intValue > JUL::Level::WARNING.intValue ?
+        level : JUL::Level::WARNING # only >= WARNING on STDERR
+      
+      root_logger.synchronized do
+        root_logger.handlers.to_a.each do |handler|
+          root_logger.remove_handler(handler) if handler.is_a?(JUL::ConsoleHandler)
+        end
+
+        root_logger.add_handler(out_handler)
+        root_logger.add_handler(err_handler)
+        root_logger.level = level
+      end
+      adjust_tomcat_loggers
+      
+      @@configured = true
+      root_logger
+    end
+    
+    # Force logging (re-)configuration.
+    # @see #configure
+    def self.configure!(log_level = nil)
+      @@configured = false
+      configure(log_level)
+    end
+    
+    # Configure logging for a web application.
+    def self.configure_web_app(web_app, context)
+      param_name, param_value = 'jruby.rack.logging', 'JUL'
+      # 1. delegate (jruby-rack) servlet log to JUL
+      if set_value = context.find_parameter(param_name)
+        return nil if set_value.upcase != param_value
+      else
+        context.add_parameter(param_name, param_value)
+      end
+      # 2. use Tomcat's JUL logger name (unless set) :
+      param_name = 'jruby.rack.logging.name'
+      unless logger_name = context.find_parameter(param_name)
+        # for a context path e.g. '/foo' most likely smt of the following :
+        # org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/foo]
+        context.add_parameter(param_name, logger_name = context.send(:logName))
+      end
+      configure # make sure 'global' logging if configured
+      
+      logger = JUL::Logger.getLogger(logger_name) # exclusive for web app
+      # avoid duplicate calls - do not configure our FileHandler twice :
+      return false if logger.handlers.find { |h| h.is_a?(FileHandler) }
+      level = parse_log_level(web_app.log, nil)
+      logger.level = level # inherits level from parent if nil
+      # delegate to root (console) output only in development mode :
+      logger.use_parent_handlers = ( web_app.environment == 'development' )
+      
+      prefix, suffix = web_app.environment, '.log' # {prefix}{date}{suffix}
+      file_handler = FileHandler.new(web_app.log_dir, prefix, suffix)
+      file_handler.rotatable = true # {prefix}{date}{suffix}
+      file_handler.formatter = web_app_formatter
+      logger.add_handler(file_handler)
+      logger
+    end
+    
+    protected
+    
+    def self.console_formatter
+      MessageFormatter.new
+    end
+    
+    def self.web_app_formatter
+      # format used by Rails "2012-06-13 16:42:21 +0200"
+      DefaultFormatter.new("yyyy-MM-dd HH:mm:ss Z")
+    end
+    
+    private
+    
+    def self.parse_log_level(log_level, default = nil)
+      log_level = log_level && log_level.to_s.upcase
+      unless JUL::Level.constants.find { |level| level.to_s == log_level }
+        log_level = { # try mapping common level names to JUL names
+          'ERROR' => 'SEVERE', 'WARN' => 'WARNING', 'DEBUG' => 'FINE' 
+        }[log_level]
+        log_level = default ? default.to_s.upcase : nil unless log_level
+      end
+      JUL::Level.parse(log_level) if log_level
+    end
+    
+    def self.adjust_tomcat_loggers
+      # org.apache.coyote.http11.Http11Protocol   INFO: Initializing ProtocolHandler ["http-bio-3000"]
+      # org.apache.catalina.core.StandardService  INFO: Starting service Tomcat
+      # org.apache.catalina.core.StandardEngine   INFO: Starting Servlet Engine: Apache Tomcat/7.0.27
+      # org.apache.catalina.startup.ContextConfig INFO: No global web.xml found
+      # org.apache.coyote.http11.Http11Protocol   INFO: Starting ProtocolHandler ["http-bio-3000"]
+      logger = JUL::Logger.get_logger('org.apache.catalina.core.StandardService')
+      logger.level = JUL::Level::WARNING if logger
+      logger = JUL::Logger.get_logger('org.apache.catalina.startup.ContextConfig')
+      logger.level = JUL::Level::WARNING if logger
+    end
+    
+    # we'd achieve logging to a production.log file while rotating it (daily)
+    class FileHandler < Java::OrgApacheJuli::FileHandler # :nodoc
+      
+      field_reader :directory, :prefix, :suffix
+      field_accessor :rotatable, :bufferSize => :buffer_size
+      
+      # JULI::FileHandler internals :
+      field_accessor :date => :_date # current date string e.g. 2012-06-26
+      
+      def initialize(directory, prefix, suffix)
+        super(directory, prefix, suffix)
+        self._date = '' # to openWriter on first #publish(record)
+      end
+      
+      def openWriter
+        # NOTE: following code is heavily based on super's internals !
+        synchronized do
+          # we're normally in the lock here (from #publish) 
+          # thus we do not perform any more synchronization
+          prev_rotatable = self.rotatable
+          begin
+            self.rotatable = false
+            # thus current file name will be always {prefix}{suffix} :
+            # due super's `prefix + (rotatable ? _date : "") + suffix`
+            super
+          ensure
+            self.rotatable = prev_rotatable
+          end
+        end
+      end
+
+      def close
+        @_close = true
+        super
+        @_close = nil
+      end
+      
+      def closeWriter
+        super
+        # the additional trick here is to rotate the closed file
+        synchronized do
+          # we're normally in the lock here (from #publish) 
+          # thus we do not perform any more synchronization
+          dir = java.io.File.new(directory).getAbsoluteFile
+          log = java.io.File.new(dir, prefix + "" + suffix)
+          if log.exists
+            date = _date
+            if date.empty?
+              date = log.lastModified
+              # we're abuse Timestamp to get a date formatted !
+              # just like the super does internally (just in case)
+              date = java.sql.Timestamp.new(date).toString[0, 10]
+            end
+            today = java.lang.System.currentTimeMillis
+            today = java.sql.Timestamp.new(today).toString[0, 10]
+            return if date == today # no need to rotate just yet
+            to_file = java.io.File.new(dir, prefix + date + suffix)
+            if to_file.exists
+              file = java.io.RandomAccessFile.new(to_file, 'rw')
+              file.seek(file.length)
+              log_channel = java.io.FileInputStream.new(log).getChannel
+              log_channel.transferTo(0, log_channel.size, file.getChannel)
+              file.close
+              log_channel.close
+              log.delete
+            else
+              log.renameTo(to_file)
+            end
+          end
+        end if rotatable && ! @_close
+      end
+      
+    end
+    
+    # We're truly missing a #formatThrown exception helper method.
+    JUL::Formatter.class_eval do
+      
+      LINE_SEP = java.lang.System.getProperty("line.separator")
+      
+      protected
+      def formatThrown(record)
+        if record.thrown
+          writer = java.io.StringWriter.new(1024)
+          print_writer = java.io.PrintWriter.new(writer)
+          print_writer.println
+          record.thrown.printStackTrace(print_writer)
+          print_writer.close
+          return writer.toString
+        end
+      end
+      
+    end
+    
+    # A message formatter only prints the log message (and the thrown value).
+    class MessageFormatter < JUL::Formatter # :nodoc
+      
+      def format(record)
+        msg = formatMessage(record)
+        msg << formatThrown(record).to_s
+        # since we're going to print Rails.logger logs and they tend
+        # to already have the ending "\n" handle such cases nicely :
+        if web_app_path(record.getLoggerName)
+          (lns = LINE_SEP) == msg[-1, 1] ? msg : msg << lns
+        else
+          msg << LINE_SEP
+        end
+      end
+      
+      # e.g. org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/foo]
+      WEB_APP_LOGGER_NAME = /org\.apache\.catalina\.core\.ContainerBase.*?\[(\/.*?)\]$/
+      
+      private
+      def web_app_path(name)
+        ( match = (name || '').match(WEB_APP_LOGGER_NAME) ) && match[1]
+      end
+      
+    end
+    
+    # A formatter that formats application file logs (e.g. production.log).
+    class DefaultFormatter < JUL::Formatter # :nodoc
+
+      # Allows customizing the date format + the time zone to be used.
+      def initialize(format = nil, time_zone = nil)
+        super()
+        @format = format ? 
+          Java::JavaText::SimpleDateFormat.new(format) : 
+            Java::JavaText::SimpleDateFormat.new
+        case time_zone
+        when Java::JavaUtil::Calendar then
+          @format.calendar = time_zone
+        when Java::JavaUtil::TimeZone then
+          @format.time_zone = time_zone
+        when String then
+          time_zone = Java::JavaUtil::TimeZone.getTimeZone(time_zone)
+          @format.time_zone = time_zone
+        when Numeric then
+          time_zones = Java::JavaUtil::TimeZone.getAvailableIDs(time_zone)
+          if time_zones.length > 0
+            time_zone = Java::JavaUtil::TimeZone.getTimeZone(time_zones[0])
+            @format.time_zone = time_zone
+          end
+        end if time_zone
+      end
+
+      JDate = Java::JavaUtil::Date
+
+      def format(record)
+        timestamp = @format.synchronized do 
+          @format.format JDate.new(record.millis)
+        end
+        level = record.level.name
+        message = formatMessage(record)
+
+        out = "#{timestamp} #{level}: #{message}"
+        out << formatThrown(record).to_s
+        (lns = "\n") == out[-1, 1] ? out : out << lns
+      end
+
+    end
+  end
+  LogFormatter = Logging::DefaultFormatter # backwards compatibility
+end

data/lib/trinidad/server.rb

@@ -1,10 +1,10 @@
 module Trinidad
-
   class Server
     attr_reader :tomcat, :config
 
     def initialize(config = Trinidad.configuration)
       load_config(config)
+      configure_logging(@config[:log])
       load_tomcat_server
       apps = create_web_apps
       load_host_monitor(apps)
@@ -33,133 +33,28 @@ module Trinidad
       @tomcat = Trinidad::Extensions.configure_server_extensions(@config[:extensions], @tomcat)
     end
 
-    def create_hosts
-      if @config[:hosts]
-        @config[:hosts].each do |apps_base, names|
-          create_host(apps_base, names)
-        end
-
-        set_default_host
-      elsif @config[:web_apps]
-        # create the hosts when they are specified for each app into web_apps. 
-        # We must create them before creating the applications.
-        @config[:web_apps].each do |name, app_config|
-          if host_names = app_config.delete(:hosts)
-            dir = app_config[:web_app_dir] || Dir.pwd
-            apps_base = File.dirname(dir) == '.' ? dir : File.dirname(dir)
-            app_config[:host] = create_host(apps_base, host_names)
-          end
-
-          set_default_host
-        end
-      else
-        @tomcat.host.app_base = @config[:apps_base] || Dir.pwd
-      end
-    end
-
-    def create_web_apps
-      apps = []
-      apps << create_from_web_apps
-      apps << create_from_apps_base
-      
-      apps.flatten.compact
-    end
-
     def load_host_monitor(apps)
       @tomcat.engine.find_children.each do |host|
-        host.add_lifecycle_listener(Trinidad::Lifecycle::Host.new(@tomcat, *apps))
-      end
-    end
-
-    def create_from_web_apps
-      if @config[:web_apps]
-        @config[:web_apps].map do |name, app_config|
-          app_config[:context_path] ||= (name.to_s == 'default' ? '' : "/#{name.to_s}")
-          app_config[:web_app_dir]  ||= Dir.pwd
-
-          create_web_app(app_config)
-        end
+        host.add_lifecycle_listener(Trinidad::Lifecycle::Host.new(self, *apps))
       end
     end
 
-    def create_from_apps_base
-      if @config[:apps_base] || @config[:hosts]
-        @tomcat.engine.find_children.map do |host|
-          apps_base = host.app_base
-
-          apps_path = Dir.glob(File.join(apps_base, '*')).
-            select {|path| !(path =~ /tomcat\.\d+$/) }
-
-          apps_path.reject! {|path| apps_path.include?(path + '.war') }
-
-          apps_path.map do |path|
-            if (File.directory?(path) || path =~ /\.war$/)
-              name = File.basename(path)
-              app_config = {
-                :context_path => (name == 'default' ? '' : "/#{name.to_s}"),
-                :web_app_dir  => File.expand_path(path),
-                :host         => host
-              }
-
-              create_web_app(app_config)
-            end
-          end
-        end.flatten
-      end
+    def ssl_enabled?
+      @config[:ssl] && !@config[:ssl].empty?
     end
 
-    def create_web_app(app_config)
-      web_app = WebApp.create(@config, app_config)
-
-      app_context = @tomcat.addWebapp(app_config[:host] || @tomcat.host, web_app.context_path, web_app.web_app_dir)
-
-      Trinidad::Extensions.configure_webapp_extensions(web_app.extensions, @tomcat, app_context)
-
-      app_context.add_lifecycle_listener(web_app.define_lifecycle)
-
-      {:context => app_context, :app => web_app, :monitor => web_app.monitor}
+    def ajp_enabled?
+      @config[:ajp] && !@config[:ajp].empty?
     end
 
-    def add_service_connector(options, protocol = nil)
-      connector = Trinidad::Tomcat::Connector.new(protocol)
-      opts = options.dup
-
-      connector.scheme = opts.delete(:scheme) if opts[:scheme]
-      connector.secure = opts.delete(:secure) || false
-      connector.port = opts.delete(:port).to_i
-
-      connector.protocol_handler_class_name = opts.delete(:protocol_handler) if opts[:protocol_handler]
-
-      opts.each do |key, value|
-        connector.setProperty(key.to_s, value.to_s)
-      end
-
-      @tomcat.service.add_connector(connector)
-      connector
+    def http_configured?
+      (@config[:http] && !@config[:http].empty?) || @config[:address] != 'localhost'
     end
-
+    
     def add_ajp_connector
       add_service_connector(@config[:ajp], 'AJP/1.3')
     end
 
-    def add_ssl_connector
-      options = @config[:ssl].merge({
-        :scheme => 'https',
-        :secure => true,
-        :SSLEnabled => 'true'
-      })
-
-      options[:keystoreFile] ||= options.delete(:keystore)
-
-      if !options[:keystoreFile] && !options[:SSLCertificateFile]
-        options[:keystoreFile] = 'ssl/keystore'
-        options[:keystorePass] = 'waduswadus'
-        create_default_keystore(options)
-      end
-
-      add_service_connector(options)
-    end
-
     def add_http_connector
       options = @config[:http] || {}
       options[:address] ||= @config[:address] if @config[:address] != 'localhost'
@@ -173,40 +68,51 @@ module Trinidad
       connector = add_service_connector(options, options[:protocol_handler] || 'HTTP/1.1')
       @tomcat.connector = connector
     end
+    
+    def add_ssl_connector
+      options = @config[:ssl].merge({
+        :scheme => 'https',
+        :secure => true,
+        :SSLEnabled => 'true'
+      })
 
-    def ssl_enabled?
-      @config[:ssl] && !@config[:ssl].empty?
-    end
+      options[:keystoreFile] ||= options.delete(:keystore)
 
-    def ajp_enabled?
-      @config[:ajp] && !@config[:ajp].empty?
-    end
+      if !options[:keystoreFile] && !options[:SSLCertificateFile]
+        options[:keystoreFile] = 'ssl/keystore'
+        options[:keystorePass] = 'waduswadus42'
+        generate_default_keystore(options)
+      end
 
-    def http_configured?
-      (@config[:http] && !@config[:http].empty?) || @config[:address] != 'localhost'
+      add_service_connector(options)
     end
+    
+    def add_service_connector(options, protocol = nil)
+      connector = Trinidad::Tomcat::Connector.new(protocol)
+      opts = options.dup
 
-    def create_default_keystore(config)
-      keystore_file = java.io.File.new(config[:keystoreFile])
+      connector.scheme = opts.delete(:scheme) if opts[:scheme]
+      connector.secure = opts.delete(:secure) || false
+      connector.port = opts.delete(:port).to_i
 
-      if (!keystore_file.parent_file.exists &&
-              !keystore_file.parent_file.mkdir)
-          raise "Unable to create keystore folder: " + keystore_file.parent_file.canonical_path
-      end
+      connector.protocol_handler_class_name = opts.delete(:protocol_handler) if opts[:protocol_handler]
 
-      keytool_args = ["-genkey",
-        "-alias", "localhost",
-        "-dname", "CN=localhost, OU=Trinidad, O=Trinidad, C=ES",
-        "-keyalg", "RSA",
-        "-validity", "365",
-        "-storepass", "key",
-        "-keystore", config[:keystoreFile],
-        "-storepass", config[:keystorePass],
-        "-keypass", config[:keystorePass]]
+      opts.each do |key, value|
+        connector.setProperty(key.to_s, value.to_s)
+      end
 
-      Trinidad::Tomcat::KeyTool.main(keytool_args.to_java(:string))
+      @tomcat.service.add_connector(connector)
+      connector
     end
 
+    def add_web_app(web_app, host = nil)
+      host ||= web_app.config[:host] || @tomcat.host
+      app_context = @tomcat.addWebapp(host, web_app.context_path, web_app.web_app_dir)
+      Trinidad::Extensions.configure_webapp_extensions(web_app.extensions, @tomcat, app_context)
+      app_context.add_lifecycle_listener(web_app.define_lifecycle)
+      app_context
+    end
+    
     def start
       trap_signals if @config[:trap]
 
@@ -219,12 +125,73 @@ module Trinidad
       @tomcat.destroy
     end
 
-    def load_default_system_properties
-      java.lang.System.set_property("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE", 'true')
+    protected
+    
+    def create_web_apps
+      apps = []
+      apps << create_from_web_apps
+      apps << create_from_apps_base
+      apps.flatten.compact
+    end
+    
+    def create_from_web_apps
+      @config[:web_apps].map do |name, app_config|
+        app_config[:context_path] ||= (name.to_s == 'default' ? '' : "/#{name}")
+        app_config[:web_app_dir]  ||= Dir.pwd
+        
+        create_web_app(app_config)
+      end if @config[:web_apps]
     end
 
-    private
+    def create_from_apps_base
+      if @config[:apps_base] || @config[:hosts]
+        @tomcat.engine.find_children.map do |host|
+          apps_base = host.app_base
+
+          apps_path = Dir.glob(File.join(apps_base, '*')).
+            select { |path| !(path =~ /tomcat\.\d+$/) }
 
+          apps_path.reject! { |path| apps_path.include?(path + '.war') }
+
+          apps_path.map do |path|
+            if File.directory?(path) || path =~ /\.war$/
+              name = File.basename(path)
+              create_web_app({
+                :context_path => (name.to_s == 'default' ? '' : "/#{name}"),
+                :web_app_dir  => File.expand_path(path),
+                :host         => host
+              })
+            end
+          end
+        end.flatten
+      end
+    end
+
+    def create_web_app(app_config)
+      web_app = WebApp.create(app_config, config)
+      WebApp::Holder.new(web_app, add_web_app(web_app))
+    end
+    
+    def create_hosts
+      if @config[:hosts]
+        @config[:hosts].each do |apps_base, names|
+          create_host(apps_base, names)
+        end
+      elsif @config[:web_apps]
+        # create the hosts when they are specified for each app into web_apps. 
+        # We must create them before creating the applications.
+        @config[:web_apps].each do |_, app_config|
+          if host_names = app_config.delete(:hosts)
+            dir = app_config[:web_app_dir] || Dir.pwd
+            apps_base = File.dirname(dir) == '.' ? dir : File.dirname(dir)
+            app_config[:host] = create_host(apps_base, host_names)
+          end
+        end
+      else
+        @tomcat.host.app_base = @config[:apps_base] || Dir.pwd
+      end
+    end
+    
     def create_host(apps_base, names)
       host_names = Array(names)
       host_name = host_names.shift
@@ -232,21 +199,25 @@ module Trinidad
         host = Trinidad::Tomcat::StandardHost.new
         host.name = host_name
         host.app_base = apps_base || Dir.pwd
-        host_names.each {|h| host.add_alias(h) } unless host_names.empty?
+        host_names.each { |name| host.add_alias(name) }
 
         @tomcat.engine.add_child host
       end
       host
     end
-
-    def set_default_host
-      # FIXME: Remove when the issue below is solved.
-      # workaround to solve this Tomcat issue: https://issues.apache.org/bugzilla/show_bug.cgi?id=52387
-      @tomcat.host = @tomcat.engine.find_children.first
+    
+    def load_default_system_properties
+      java.lang.System.set_property("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE", 'true')
     end
-
+    
+    def configure_logging(log_level)
+      Trinidad::Logging.configure(log_level)
+    end
+    
+    private
+    
     def add_default_web_app!(config)
-      if (!config[:web_apps] && !config[:apps_base] && !config[:hosts])
+      if !config[:web_apps] && !config[:apps_base] && !config[:hosts]
         default_app = {
           :context_path => config[:context_path],
           :web_app_dir => config[:web_app_dir] || Dir.pwd,
@@ -257,7 +228,29 @@ module Trinidad
         config[:web_apps] = { :default => default_app }
       end
     end
+    
+    def generate_default_keystore(config)
+      keystore_file = java.io.File.new(config[:keystoreFile])
+
+      if (!keystore_file.parent_file.exists &&
+              !keystore_file.parent_file.mkdir)
+          raise "Unable to create keystore folder: " + keystore_file.parent_file.canonical_path
+      end
 
+      key_tool_args = ["-genkey",
+        "-alias", "localhost",
+        "-dname", "CN=localhost, OU=Trinidad, O=Trinidad, C=ES",
+        "-keyalg", "RSA",
+        "-validity", "365",
+        "-storepass", "key",
+        "-keystore", config[:keystoreFile],
+        "-storepass", config[:keystorePass],
+        "-keypass", config[:keystorePass]]
+
+      key_tool = Java::SunSecurityTools::KeyTool
+      key_tool.main key_tool_args.to_java(:string)
+    end
+    
     def trap_signals
       trap('INT') { stop }
       trap('TERM') { stop }