torquebox-core 3.2.0-java → 4.0.0.alpha1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da4f0ba096b358f19a5bc5761a10236f7a60f2fd
-  data.tar.gz: 316aea8fd629d6ddf05e3b2a531a8f3424c68702
+  metadata.gz: e8cf11a23000d1db2bbf771b2d4a8ae8c177cc2d
+  data.tar.gz: b8875fb8ee9f5d3d144ecad52976ae5aa1e69f05
 SHA512:
-  metadata.gz: f4d6ab43537ebfb98c7b5d4610982d50dce27fee9389a2c6fe582ab41b1f8a32fcbaf762b30e2bd578f04dfc396be3eb5adf4ffcbc8d41c80370a3c16794f1ea
-  data.tar.gz: 35e33b27a2fd5db90e200a050fca8bcd6ce2d04f24d47b2005ca671ddf6c3c221454690c6adacd3ec77b72a810f2d961087ca84842b5ea0dbf97b6899c7344d0
+  metadata.gz: 7f867844665d4c0f451b6de698c9b9f3d08ec046a65d0a3992e36c1040c9541990683d02d8373ccdbf22cc00690cf106e72dbb0179084d68054cf026eb449bfe
+  data.tar.gz: d57604b36264857fa2ce6d19db91b962f9450503255ab1c2a90635470a8a04736aeb02143460b654fd19133629e7b5a3aeaf6b6355502b5d90d427febb16e273

data/bin/torquebox

@@ -0,0 +1,20 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+java.lang.System.set_property('logback.configurationFile',
+                              File.join(File.dirname(__FILE__), '..', 'lib', 'resources', 'logback-cli.xml'))
+
+require 'torquebox-core'
+
+cli = TorqueBox::CLI.new(ARGV)

data/lib/resources/logback-cli.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<configuration>
+  <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%date{HH:mm:ss.SSS} %-5level %message%n</pattern>
+    </encoder>
+  </appender>
+  <root level="INFO">
+    <appender-ref ref="Console"/>
+  </root>
+</configuration>

data/lib/torquebox-core.rb

@@ -1,13 +1,54 @@
-module TorqueboxCore
-  VERSION = '3.2.0'
-  MAVEN_VERSION = '3.2.0'
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "pathname"
+
+module TorqueBox
+
+  # @api private
+  JAR_MARKER = "torquebox_jar_marker"
+
+  # @api private
+  EXPLODED_JAR = !JRuby.classloader_resources(JAR_MARKER).empty?
+
+  class Jars
+    class << self
+      def register_and_require(jar)
+        path = Pathname.new(jar)
+        raise 'Jars must be registered using absolute paths' unless path.absolute?
+        jar = path.expand_path.to_s
+        @jars ||= []
+        @jars << jar
+        require jar unless EXPLODED_JAR
+      end
+
+      def list
+        @jars
+      end
+    end
+  end
 end
-begin
-  require 'java'
-  require File.dirname(__FILE__) + '/torquebox-core.jar'
-rescue LoadError
-  puts 'JAR-based gems require JRuby to load. Please visit www.jruby.org.'
-  raise
+
+Dir.glob("#{File.dirname(__FILE__)}/wunderboss-jars/*.jar") do |jar|
+  TorqueBox::Jars.register_and_require(jar)
 end
 
-load File.dirname(__FILE__) + '/gem_hook.rb' if File.exists?( File.dirname(__FILE__) + '/gem_hook.rb')
+TorqueBox::Jars.register_and_require("#{File.dirname(__FILE__)}/torquebox-core.jar")
+require 'torquebox/cli'
+require 'torquebox/cli/jar'
+require 'torquebox/cli/war'
+require 'torquebox/logger'
+require 'torquebox/option_utils'
+require 'torquebox/version'
+require 'torquebox/codecs'

data/lib/torquebox/cli.rb

@@ -0,0 +1,129 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'optparse'
+
+module TorqueBox
+  class CLI
+
+    class << self
+      def extensions
+        @extensions ||= {}
+      end
+
+      def extension_descriptions
+        @extension_descriptions ||= {}
+      end
+
+      def register_extension(command, extension, description)
+        extensions[command] = extension
+        extension_descriptions[command] = description
+      end
+    end
+
+    def initialize(argv)
+      require_torquebox_gems
+      options = {}
+      extension = TorqueBox::CLI.extensions[argv.first]
+      parser = OptionParser.new
+      if extension
+        setup_extension_parser(extension, argv.shift, parser, options)
+      else
+        setup_usage_parser(parser)
+      end
+
+      setup_common_parser(parser, options)
+      begin
+        parser.parse!(argv)
+      rescue OptionParser::InvalidOption => e
+        puts e.message
+        puts
+        puts parser
+        exit 1
+      end
+
+
+      if extension
+        log_level = case options.delete(:verbosity)
+                    when :quiet then 'ERROR'
+                    when :verbose then 'DEBUG'
+                    when :really_verbose then 'TRACE'
+                    else 'INFO'
+                    end
+        TorqueBox::Logger.log_level = log_level
+        extension.run(argv, options)
+      else
+        puts parser
+        exit 1
+      end
+    end
+
+    def setup_extension_parser(extension, command, parser, options)
+      parser.banner = "Usage: torquebox #{command} #{extension.usage_parameters}"
+      parser.separator TorqueBox::CLI.extension_descriptions[command]
+      parser.separator ""
+      parser.separator "#{command} options:"
+      extension.setup_parser(parser, options)
+    end
+
+    def setup_usage_parser(parser)
+      parser.banner = "Usage: torquebox [command] [options]"
+      parser.separator ""
+      parser.separator "Commands:"
+      TorqueBox::CLI.extensions.keys.each do |command|
+        description = TorqueBox::CLI.extension_descriptions[command]
+        command = "#{command}:".ljust(8)
+        parser.separator "    #{command} #{description}"
+      end
+      parser.separator ""
+      parser.separator "Installing additional torquebox gems may provide additional commands."
+      parser.separator "'torquebox [command] -h' for additional help on each command"
+    end
+
+    def setup_common_parser(parser, options)
+      parser.separator ""
+      parser.separator "Common options:"
+      parser.on '-q', '--quiet', 'Log only errors' do
+        options[:verbosity] = :quiet
+      end
+      parser.on '-v', '--verbose', 'Log more - use twice for even more' do
+        if options[:verbosity] == :verbose
+          options[:verbosity] = :really_verbose
+        else
+          options[:verbosity] = :verbose
+        end
+      end
+      parser.on_tail('-h', '--help', 'Show this message') do
+        puts parser
+        exit 1
+      end
+      parser.on_tail('--version', 'Show version') do
+        puts "TorqueBox #{TorqueBox::VERSION}"
+        exit 1
+      end
+    end
+
+    def require_torquebox_gems
+      # Ensure all other known TorqueBox gems are loaded so we can see their
+      # CLI extensions and jars
+      %W(torquebox-web torquebox-messaging torquebox-scheduling torquebox-caching).each do |gem|
+        begin
+          require gem
+        rescue LoadError
+        end
+      end
+    end
+
+  end
+end

data/lib/torquebox/cli/jar.rb

@@ -0,0 +1,336 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'fileutils'
+require 'pathname'
+require 'rbconfig'
+require 'tmpdir'
+require 'torquebox-core'
+
+module TorqueBox
+  class CLI
+    class Jar
+
+      DEFAULT_INIT = "require 'torquebox-web'; \
+if org.projectodd.wunderboss.WunderBoss.options.get('wildfly-service').nil?; \
+  begin; \
+    TorqueBox::CLI.new(ARGV.unshift('run')); \
+  rescue SystemExit => e; \
+    status = e.respond_to?(:status) ? e.status : 0; \
+    java.lang.System.exit(status); \
+  end; \
+else; \
+  TorqueBox::Web.run(:rackup => '$$rackup$$'); \
+end;"
+
+      def initialize
+        @logger = org.projectodd.wunderboss.WunderBoss.logger('TorqueBox')
+        @classpath = []
+      end
+
+      def usage_parameters
+        "[options]"
+      end
+
+      def option_defaults
+        {
+          :destination => '.',
+          :jar_name => "#{File.basename(Dir.pwd)}.jar",
+          :include_jruby => true,
+          :bundle_gems => true,
+          :bundle_without => %W(development test assets),
+          :rackup => 'config.ru'
+        }
+      end
+
+      def available_options
+        defaults = option_defaults
+        [{
+           :name => :destination,
+           :switch => '--destination PATH',
+           :description => "Destination directory for the jar file (default: #{defaults[:destination]})"
+         },
+         {
+           :name => :jar_name,
+           :switch => '--name NAME',
+           :description => "Name of the jar file (default: #{defaults[:jar_name]})"
+         },
+         {
+           :name => :include_jruby,
+           :switch => '--[no-]include-jruby',
+           :description => "Include JRuby in the jar (default: #{defaults[:include_jruby]})"
+         },
+         {
+           :name => :bundle_gems,
+           :switch => '--[no-]bundle-gems',
+           :description => "Bundle gem dependencies in the jar (default: #{defaults[:bundle_gems]})"
+         },
+         {
+           :name => :bundle_without,
+           :switch => '--bundle-without GROUPS',
+           :description => "Bundler groups to skip (default: #{defaults[:bundle_without]})",
+           :type => Array
+         },
+         {
+           :name => :main,
+           :switch => '--main MAIN',
+           :description => 'File to require to bootstrap the application (if not given, assumes a web app)'
+         }]
+      end
+
+      def setup_parser(parser, options)
+        available_options.each do |opt|
+          parser.on(*(opt.values_at(:short, :switch, :type, :description).compact)) do |arg|
+            options[opt[:name]] = arg
+          end
+        end
+        parser.on('--envvar KEY=VALUE',
+                  'Specify an environment variable to set before running the app') do |arg|
+          key, value = arg.split('=')
+          if key.nil? || value.nil?
+            $stderr.puts "Error: Environment variables must be separated by '='"
+            exit 1
+          end
+          options[:envvar] ||= {}
+          options[:envvar][key] = value
+        end
+      end
+
+      def run(_argv, options)
+        options = option_defaults.merge(options)
+        jar_path = File.join(options[:destination], options[:jar_name])
+        @logger.debug("Creating jar with options {}", options.inspect)
+
+        if options[:main]
+          init = "require '#{options[:main]}'"
+        else
+          init = DEFAULT_INIT.sub('$$rackup$$', options[:rackup])
+        end
+
+        jar_builder = org.torquebox.core.JarBuilder.new
+        jar_builder.add_manifest_attribute("Main-Class", "org.torquebox.core.TorqueBoxMain")
+        jar_builder.add_string(TorqueBox::JAR_MARKER, "")
+
+        add_torquebox_files(jar_builder)
+
+        if options[:include_jruby]
+          add_jruby_files(jar_builder)
+        end
+
+        add_app_files(jar_builder)
+
+        if options[:bundle_gems]
+          tmpdir = Dir.mktmpdir("tmptorqueboxjar", ".")
+          add_bundler_files(jar_builder, tmpdir, options[:bundle_without])
+        end
+
+        jar_builder.add_string("META-INF/app.properties",
+                               app_properties(options[:envvar] || {}, init))
+
+        if File.exist?(jar_path)
+          @logger.info("Removing {}", jar_path)
+          FileUtils.rm_f(jar_path)
+        end
+        @logger.info("Writing {}", jar_path)
+        jar_builder.create(jar_path)
+        jar_path
+      ensure
+        FileUtils.rm_rf(tmpdir) if tmpdir
+      end
+
+      def add_jruby_files(jar_builder)
+        @logger.trace("Adding JRuby files to jar...")
+        rb_config = RbConfig::CONFIG
+        add_files(jar_builder,
+                  :file_prefix => rb_config["prefix"],
+                  :pattern => "/*",
+                  :jar_prefix => "jruby")
+        add_files(jar_builder,
+                  :file_prefix => rb_config["libdir"],
+                  :pattern => "/**/*",
+                  :jar_prefix => "jruby/lib",
+                  :exclude => ["jruby.jar", "ruby/gems/shared"])
+        add_files(jar_builder,
+                  :file_prefix => rb_config["bindir"],
+                  :pattern => "/*",
+                  :jar_prefix => "jruby/bin")
+        add_jar(jar_builder, "#{rb_config['libdir']}/jruby.jar")
+      end
+
+      def add_app_files(jar_builder)
+        @logger.trace("Adding application files to jar...")
+        add_files(jar_builder,
+                  :file_prefix => Dir.pwd,
+                  :pattern => "/**/*",
+                  :jar_prefix => "app",
+                  :exclude => [%r{^/[^/]*\.(jar|war)}])
+      end
+
+      def add_bundler_files(jar_builder, tmpdir, bundle_without)
+        @logger.trace("Adding bundler files to jar...")
+        unless File.exist?(ENV['BUNDLE_GEMFILE'] || 'Gemfile')
+          @logger.info("No Gemfile found - skipping gem dependencies")
+          return {}
+        end
+        @logger.info("Bundling gem dependencies")
+        require 'bundler'
+
+        copy_bundle_config(tmpdir)
+
+        vendor_dir_exists = File.exist?('vendor')
+        cache_dir_exists = File.exist?('vendor/cache')
+        bundle_dir_exists = File.exist?('vendor/bundle')
+        already_cached = Dir.glob('vendor/cache/*.gem').count > 0
+        already_bundled = Pathname.new(Bundler.settings.path).relative?
+
+        lockfile = Bundler.default_lockfile
+        original_lockfile = File.exist?(lockfile) ? File.read(lockfile) : nil
+
+        cache_gems(tmpdir) unless already_cached
+        bundle_gems(tmpdir, bundle_without) unless already_bundled
+        copy_cached_gems(tmpdir) unless already_cached
+        copy_and_restore_lockfile(tmpdir, lockfile, original_lockfile)
+
+        add_files(jar_builder,
+                  :file_prefix => tmpdir,
+                  :pattern => "/{**/*,.bundle/**/*}",
+                  :jar_prefix => "app",
+                  :exclude => TorqueBox::Jars.list.map { |j| File.basename(j)  })
+        Gem.default_path.each do |prefix|
+          add_files(jar_builder,
+                    :file_prefix => prefix,
+                    :pattern => "/**/bundler-#{Bundler::VERSION}{*,/**/*}",
+                    :jar_prefix => "jruby/lib/ruby/gems/shared")
+        end
+      ensure
+        FileUtils.rm_rf('vendor/bundle') unless bundle_dir_exists
+        FileUtils.rm_rf('vendor/cache') unless cache_dir_exists
+        FileUtils.rm_rf('vendor') unless vendor_dir_exists
+      end
+
+      def copy_bundle_config(tmpdir)
+        if File.exist?('.bundle/config')
+          FileUtils.mkdir_p("#{tmpdir}/.bundle")
+          FileUtils.cp('.bundle/config', "#{tmpdir}/.bundle")
+        end
+      end
+
+      def cache_gems(tmpdir)
+        eval_in_new_ruby <<-EOS
+          ENV['BUNDLE_APP_CONFIG'] = "#{tmpdir}/.bundle"
+          require 'bundler/cli'
+          Bundler::CLI.start(['cache', '--all'])
+        EOS
+      end
+
+      def bundle_gems(tmpdir, bundle_without)
+        install_options = %W(--local --path vendor/bundle --no-cache)
+        unless bundle_without.empty?
+          install_options += %W(--without #{bundle_without.join(' ')})
+        end
+        eval_in_new_ruby <<-EOS
+          ENV['BUNDLE_APP_CONFIG'] = "#{tmpdir}/.bundle"
+          require 'bundler/cli'
+          Bundler::CLI.start(['install'] + #{install_options.inspect})
+        EOS
+        FileUtils.mkdir_p("#{tmpdir}/vendor/bundle/jruby")
+        FileUtils.cp_r('vendor/bundle/jruby', "#{tmpdir}/vendor/bundle/")
+      end
+
+      def copy_cached_gems(tmpdir)
+        FileUtils.mkdir_p("#{tmpdir}/vendor/cache")
+        FileUtils.cp_r('vendor/cache', "#{tmpdir}/vendor/")
+      end
+
+      def copy_and_restore_lockfile(tmpdir, lockfile, original_lockfile)
+        new_lockfile = File.exist?(lockfile) ? File.read(lockfile) : nil
+        FileUtils.cp(lockfile, "#{tmpdir}/Gemfile.lock") if new_lockfile
+        if original_lockfile.nil? && !new_lockfile.nil?
+          FileUtils.rm_f(lockfile)
+        elsif original_lockfile != new_lockfile
+          File.open(lockfile, 'w') { |f| f.write(original_lockfile) }
+        end
+      end
+
+      def add_jar(jar_builder, jar)
+        @logger.debug("Adding jar {}", jar)
+        jar_name = "jars/#{File.basename(jar)}"
+        @classpath << "${extract_root}/#{jar_name}"
+        jar_builder.add_file(jar_name, jar)
+      end
+
+      def add_torquebox_files(jar_builder)
+        TorqueBox::Jars.list.each do |jar|
+          if File.basename(jar) =~ /^wunderboss-(rack|ruby).*?\.jar$/
+            add_jar(jar_builder, jar)
+          else
+            @logger.debug("Shading jar {}", jar)
+            jar_builder.shade_jar(jar)
+          end
+        end
+      end
+
+      def add_files(jar_builder, options)
+        prefix = options[:file_prefix]
+        prefix += '/' unless prefix.end_with?('/')
+        Dir.glob("#{prefix}#{options[:pattern]}").each do |file|
+          suffix = file.sub(prefix, '')
+          excludes = [options[:exclude]].compact.flatten
+          next if excludes.any? do |exclude|
+            if exclude.is_a?(Regexp)
+              exclude =~ suffix
+            else
+              suffix.include?(exclude)
+            end
+          end
+          next if suffix.include?("tmptorqueboxjar")
+          in_jar_name = options[:jar_prefix] ? File.join(options[:jar_prefix], suffix) : suffix
+          jar_builder.add_file(in_jar_name, file)
+        end
+      end
+
+      def eval_in_new_ruby(script)
+        ruby = org.jruby.Ruby.new_instance
+        unless %W(DEBUG TRACE).include?(TorqueBox::Logger.log_level)
+          dev_null = PLATFORM =~ /mswin/ ? 'NUL' : '/dev/null'
+          ruby.evalScriptlet("$stdout = File.open('#{dev_null}', 'w')")
+        end
+        ruby.evalScriptlet(script)
+      end
+
+      def app_properties(env, init)
+        env_str = env.map do |key, value|
+          "ENV['#{key}']||='#{value}';"
+        end.join(' ')
+        classpath_str = @classpath.join(':')
+
+        <<-EOS
+language=ruby
+extract_paths=app/:jruby/:jars/
+root=${extract_root}/app
+classpath=#{classpath_str}
+init=ENV['BUNDLE_GEMFILE'] = nil; \
+#{env_str} \
+require "bundler/setup"; \
+#{init}; \
+require "torquebox/spec_helpers"; \
+TorqueBox::SpecHelpers.booted
+EOS
+      end
+    end
+  end
+end
+
+TorqueBox::CLI.register_extension('jar', TorqueBox::CLI::Jar.new,
+                                  'Create an executable jar from an application')