warbler 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b68e1cba9a7e9e892eb9f5950fe177c07a7bba4f349813e7bb9b18e82ad9bbcc
-  data.tar.gz: b0ed237291f26d1a79204499007d1527a97899214672474ef7cacd0aeb8591c4
+  metadata.gz: 34fe8d21840c8677062066d0df7979b427676ec18dc428e268fe7973f0bb320f
+  data.tar.gz: 5a68813d0b80ad5b705cb2cd1045ad65ef618c28ee3e9316ca179bf1f3522574
 SHA512:
-  metadata.gz: 577dc3b4f393e6f4891e42806efdd64ab3ce8d3d222ff6b8ba6994a5f9376461ebcde493433d8875468cfacd8b63ec9fd058d26d8e6672e54458aa4120420e47
-  data.tar.gz: d6a263d75de2a1f2f179751face07f9b922002a7bcaa7b0534289a2188067e52ac8131fd814014421008912cb183d3afb120a6d51566072c3c737a4ed90b05b4
+  metadata.gz: 9c84e0abec9a450e7fdbacd1eb88b0f17da8da95defb6092c476e30f4d90d72cf9413cea636716ffe71cbe170904b71766a5b4e80c7ceea68cda3856e9636675
+  data.tar.gz: b5c5aef56f17c17c2f6b30d1faa52664b72c685c82b96961efaee9fd5a5bc1a5561e0547bbd17d3824d0c61638bf3bac19c4d919d5b52b6f9070f2df0b125751

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.1.2
+
+- #649: fix: further improve isolation of warbled jars/wars from host bundler configuration
+- #648: fix: further improve isolation of warbled jars/wars from user/host gem paths
+- #465: fix: remove duplication of bundler path gems in warbled jars/wars
+- #331: fix: correct support for `gem_excludes` inside bundler git specs
+- chore: relax jruby-rack requirement to allow compatibility with upcoming 2.0.x
+
 ## 2.1.1
 
 - #624, #635, #623: fix: ensure compatibility with JRuby 10.1

data/README.rdoc

@@ -258,13 +258,7 @@ https://github.com/jruby/warbler/issues.
 
 === Common issues with executable wars
 
-If your app isn't working or starting up correctly: 
-
--  <b>Missing Logging:</b>
-   If your boot process is failing silently (or with a logging warning), try configuring the logger
-   manually:
-  
-    java "-Dorg.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.StdErrLog" -jar my_app.war
+If your app isn't working or starting up correctly:
 
 -  <b>CompatVersion errors:</b>
    If you are getting <tt>java.lang.NoClassDefFoundError: org/jruby/CompatVersion</tt> errors at start-up

data/ext/WarMain.java

@@ -304,22 +304,21 @@ public class WarMain extends JarMain {
 
     protected String locateExecutableScript(final String executable, final CharSequence envPreScript) {
         return ( envPreScript == null ? "" : envPreScript + " \n" ) +
-        "begin\n" + // locate the executable within gemspecs :
-        "  require 'rubygems' unless defined?(Gem) \n" +
-          "  begin\n" + // add bundled gems to load path :
-          "    require 'bundler' \n" +
-          "  rescue LoadError\n" + // bundler not used
-          "  else\n" +
-          "    env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] \n" + // init.rb sets ENV['RAILS_ENV'] ||= ...
-          "    env ? Bundler.setup(:default, env) : Bundler.setup(:default) \n" +
-          "  end if ENV_JAVA['warbler.bundler.setup'] != 'false' \n" + // java -Dwarbler.bundler.setup=false -jar my.war -S pry
-        "  exec = '"+ executable +"' \n" +
-        "  spec = Gem::Specification.find { |s| s.executables.include?(exec) } \n" +
-        "  spec ? spec.bin_file(exec) : nil \n" +
-        // returns the full path to the executable
-        "rescue SystemExit => e\n" +
-        "  e.status\n" +
-        "end";
+            "begin\n" + // locate the executable within gemspecs :
+            "  begin\n" + // add bundled gems to load path :
+            "    require 'bundler' \n" +
+            "  rescue LoadError\n" + // bundler not used
+            "  else\n" +
+            "    env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] \n" + // init.rb sets ENV['RAILS_ENV'] ||= ...
+            "    env ? Bundler.setup(:default, env) : Bundler.setup(:default) \n" +
+            "  end if ENV_JAVA['warbler.bundler.setup'] != 'false' \n" + // java -Dwarbler.bundler.setup=false -jar my.war -S pry
+            "  exec = '"+ executable +"' \n" +
+            "  spec = Gem::Specification.find { |s| s.executables.include?(exec) } \n" +
+            "  spec ? spec.bin_file(exec) : nil \n" +
+            // returns the full path to the executable
+            "rescue SystemExit => e\n" +
+            "  e.status\n" +
+            "end";
     }
 
     protected void initJRubyScriptingEnv(Object scriptingContainer) throws Exception {

data/lib/warbler/config.rb

@@ -60,8 +60,10 @@ module Warbler
     # Whether to include dependent gems (default true)
     attr_accessor :gem_dependencies
 
-    # Array of regular expressions matching relative paths in gems to
-    # be excluded from the war. Default contains no exclusions.
+    # Array of regular expressions matching paths *inside* packed gems to be
+    # excluded from the archive. Paths are matched relative to each gem's root
+    # (for git-sourced gems: the repository checkout root). Default contains no
+    # exclusions.
     attr_accessor :gem_excludes
 
     # Whether to exclude **/*.log files (default is true)

data/lib/warbler/jar.rb

@@ -219,7 +219,7 @@ module Warbler
           # OK if the gem does not exists as its un-packed on the "shared" path
           # ... at least gem spec.spec_file should exists although not crucial
           if JRUBY_VERSION != JRubyJars::VERSION
-            warn "skipping #{spec.name} default gem (assuming its part of jruby-jars #{JRubyJars::VERSION})" unless silent?
+            warn "skipping #{spec.name} default gem (assuming its part of jruby-jars #{JRubyJars::VERSION})"
           end
         else
           warn "skipping #{spec.name} gem (#{full_gem_path.to_s} does not exist)"

data/lib/warbler/templates/bundler.erb

@@ -1,4 +1 @@
 ENV['BUNDLE_WITHOUT'] = '<%= config.bundle_without.join(':') %>'
-<% if config.bundler[:frozen] -%>
-ENV['BUNDLE_FROZEN'] = '1'
-<% end -%>

data/lib/warbler/templates/jar.erb

@@ -4,10 +4,12 @@ ENV['GEM_HOME'] <%= config.override_gem_home ? '=' : '||=' %> File.expand_path(F
 ENV['GEM_HOME'] <%= config.override_gem_home ? '=' : '||=' %> File.expand_path(File.join('..', '..', '<%= config.relative_gem_path %>'), __FILE__)
 <% end -%>
 <% if config.override_gem_home -%>
-ENV['GEM_PATH'] = nil # RGs sets Gem.paths.path = Gem.default_path + [ GEM_HOME ]
+<%# GEM_HOME (the packed gems) is always on Gem.path; adding only the runtime's own default %>
+<%# gem dir (Ruby's "bundled gems") excludes host gem paths (e.g. Gem.user_dir aka ~/.gem) %>
+ENV['GEM_PATH'] = Gem.default_dir
 <% end -%>
 <% if config.bundler && config.bundler[:gemfile_path] -%>
 ENV['BUNDLE_GEMFILE'] = File.expand_path(File.join('..', '..', '<%= config.bundler[:gemfile_path] %>'), __FILE__)
 <% end -%>
 <%# Ensure any cached paths are cleared; otherwise behaviour can be indeterminate if the paths have already been read %>
-# Gem.clear_paths
+Gem.clear_paths

data/lib/warbler/templates/war.erb

@@ -6,7 +6,9 @@ if $servlet_context.nil?
 else
   ENV['GEM_HOME'] <%= config.override_gem_home ? '=' : '||=' %> $servlet_context.getRealPath('<%= config.gem_path %>')
 <% if config.override_gem_home -%>
-  ENV['GEM_PATH'] = nil
+  <%# GEM_HOME (the packed gems) is always on Gem.path; adding only the runtime's own default %>
+  <%# gem dir (Ruby's "bundled gems") excludes host gem paths (e.g. Gem.user_dir aka ~/.gem) %>
+  ENV['GEM_PATH'] = Gem.default_dir
 <% end -%>
 <% if config.bundler && config.bundler[:gemfile_path] -%>
   ENV['BUNDLE_GEMFILE'] ||= $servlet_context.getRealPath('/<%= config.bundler[:gemfile_path] %>')

data/lib/warbler/traits/bundler.rb

@@ -14,6 +14,23 @@ module Warbler
       include PathmapHelper
       include BundlerHelper
 
+      # Bundler settings enforced in the packed application via a generated
+      # *.bundle/config*, the highest-precedence documented configuration level:
+      BUNDLE_CONFIG_DEFAULTS = {
+        # BUNDLE_VERSION: disable bundler's "auto-switch" to Gemfile.lock's BUNDLED WITH bundler version
+        #   (bundler restarts the process to do so, which cannot work inside a servlet container or self-contained executable jar)
+        'BUNDLE_VERSION' => 'system',
+        # BUNDLE_FROZEN: fail fast with a descriptive error on Gemfile vs Gemfile.lock drift instead of attempting
+        #   a runtime re-resolution
+        'BUNDLE_FROZEN' => 'true',
+        # BUNDLE_PATH__SYSTEM (path.system): pin bundler to the "system" gems - which are the packed gems, via
+        #   GEM_HOME/GEM_PATH from *init.rb* - immune to a BUNDLE_PATH/BUNDLE_DEPLOYMENT leaking in from the host's
+        #   environment or ~/.bundle/config
+        'BUNDLE_PATH__SYSTEM' => 'true',
+        # BUNDLE_AUTO_INSTALL: never install gems at boot time, even if the host's environment or global config enables it
+        'BUNDLE_AUTO_INSTALL' => 'false'
+      }.freeze
+
       def self.detect?
         File.exist?(ENV['BUNDLE_GEMFILE'] || 'Gemfile')
       end
@@ -36,6 +53,8 @@ module Warbler
         config.gem_dependencies = false # Bundler takes care of these
         config.bundler = {} if config.bundler == true
 
+        warn_on_bundler_version_mismatch
+
         bundler_specs.each do |spec|
           spec = to_spec(spec)
 
@@ -45,11 +64,12 @@ module Warbler
             config.bundler[:git_specs] << spec
           when ::Bundler::Source::Path
             unless bundler_source_is_warbled_gem_itself?(spec.source)
-              if spec.source.path && spec.source.path.relative?
-                # include (assuming) relative *[APP_ROOT]/gem/path*
-                # NOTE: might be tuned to only add gemspec.files ...
+              if spec.source.path&.relative?
+                # pack the gem at its relative *[APP_ROOT]/gem/path* location - at runtime bundler resolves the path
+                # source relative to the packed Gemfile.
+                # Deliberately NOT also added to config.gems: bundler never materializes path gems from the gem
+                # repository; doing so would cause duplication.
                 config.includes += FileList[File.join(spec.source.path, '**/*')]
-                config.gems << spec # probably not really needed
               else
                 warn("Bundler `path' components are not fully supported.\n" +
                      "The `#{spec.full_name}' component was not bundled.\n" +
@@ -57,13 +77,12 @@ module Warbler
               end
             end
           else
-            config.gems << spec
+            config.gems << spec unless spec.respond_to?(:default_gem?) && spec.default_gem?
           end
         end
         config.bundler[:gemfile]  = ::Bundler.default_gemfile
         config.bundler[:gemfile_path] = apply_pathmaps(config, relative_from_pwd(::Bundler.default_gemfile), :application)
         config.bundler[:lockfile] = ::Bundler.default_lockfile
-        config.bundler[:frozen] = ::Bundler.settings[:frozen]
         path = ::Bundler.settings[:path]
         config.excludes += [path, "#{path}/**/*"] if path
         config.init_contents << "#{config.warbler_templates}/bundler.erb"
@@ -73,42 +92,41 @@ module Warbler
         add_bundler_files(jar) if config.bundler
       end
 
-      # Add Bundler Gemfiles and git repositories to the archive.
+      # Add Bundler Gemfiles, .bundle/config and git repositories to the archive.
       def add_bundler_files(jar)
         gemfile  = relative_from_pwd(config.bundler[:gemfile])
         lockfile = relative_from_pwd(config.bundler[:lockfile])
+        bundle_config = File.join('.bundle', 'config')
+
         jar.files[apply_pathmaps(config, gemfile, :application)] = config.bundler[:gemfile].to_s
-        if File.exist?(lockfile)
-          jar.files[apply_pathmaps(config, lockfile, :application)] = config.bundler[:lockfile].to_s
-        end
-        if config.bundler[:git_specs]
-          pathmap = "#{config.relative_gem_path}/bundler/gems/%p"
-          pathmap.sub!(%r{^/+}, '')
-          config.pathmaps.git = [pathmap]
-          config.bundler[:git_specs].each do |spec|
-            full_gem_path = Pathname.new(spec.full_gem_path)
-
-            gem_relative_path = full_gem_path.relative_path_from(::Bundler.install_path)
-            filenames = []
-            gem_relative_path.each_filename { |f| filenames << f }
-
-            exclude_gems = true
-            unless filenames.empty?
-              full_gem_path = Pathname.new(::Bundler.install_path) + filenames.first
-              exclude_gems = false
-            end
+        jar.files[apply_pathmaps(config, lockfile, :application)] = config.bundler[:lockfile].to_s if File.exist?(lockfile)
+        # NOTE: in-memory content must be an IO - jar creation treats plain Strings as source file paths
+        jar.files[apply_pathmaps(config, bundle_config, :application)] = StringIO.new(bundle_config_contents)
 
-            if spec.groups.include?(:warbler_excluded)
-              pattern = "#{full_gem_path.to_s}/**/#{spec.name}.gemspec" # #42: gemspec only to avert Bundler error
-            else
-              pattern = "#{full_gem_path.to_s}/**/*"
-            end
+        add_bundler_git_specs(config.bundler[:git_specs], jar) if config.bundler[:git_specs]
+      end
 
-            FileList[pattern].each do |src|
-              f = Pathname.new(src).relative_path_from(full_gem_path).to_s
-              next if exclude_gems && config.gem_excludes && config.gem_excludes.any? {|rx| f =~ rx }
-              jar.files[apply_pathmaps(config, File.join(full_gem_path.basename, f), :git)] = src
-            end
+      private
+
+      def add_bundler_git_specs(git_specs, jar)
+        config.pathmaps.git = ["#{config.relative_gem_path}/bundler/gems/%p".sub(%r{^/+}, '')]
+
+        # a git source checkout may contain multiple gems (spec.full_gem_path being a sub-directory) - bundler expects
+        # the complete repository checkout under bundler/gems/<repo>-<ref>, so pack from its root (once per repository,
+        # even when several specs share the checkout)
+        checkout_paths = git_specs.map do |spec|
+          full_gem_path = Pathname.new(spec.full_gem_path)
+          filenames = full_gem_path.relative_path_from(::Bundler.install_path).each_filename.to_a
+          filenames.empty? ? full_gem_path : Pathname.new(::Bundler.install_path) + filenames.first
+        end.uniq
+
+        checkout_paths.each do |checkout_path|
+          FileList["#{checkout_path.to_s}/**/*"].each do |src|
+            f = Pathname.new(src).relative_path_from(checkout_path).to_s
+            # NOTE: for git sources the excludes match relative to the packed repository checkout root (the gem root,
+            # except multi-gem repos)
+            next if config.gem_excludes && config.gem_excludes.any? { |rx| f =~ rx }
+            jar.files[apply_pathmaps(config, File.join(checkout_path.basename, f), :git)] = src
           end
         end
       end
@@ -121,17 +139,32 @@ module Warbler
         end
       end
 
-      private
+      def warn_on_bundler_version_mismatch
+        lockfile = ::Bundler.default_lockfile
+        return unless lockfile && File.exist?(lockfile)
+        locked = ::Bundler::LockfileParser.new(File.read(lockfile)).bundler_version rescue nil
+        if locked && locked.to_s != ::Bundler::VERSION
+          warn("Gemfile.lock BUNDLED WITH (#{locked}) does not match the bundler running warbler (#{::Bundler::VERSION}).\n" +
+               "The packed application will boot with the default bundler of the packed JRuby (jruby-jars),\n" +
+               "consider re-generating Gemfile.lock with a matching bundler version.")
+        end
+      end
+
+      # Contents for the packed *.bundle/config*: only warbler's deployment settings, deliberately independent of the
+      # application's build-time bundler configuration.
+      def bundle_config_contents
+        require 'yaml'
+        settings = BUNDLE_CONFIG_DEFAULTS.dup
+        # frozen mode errors without a lockfile - do not force it upon applications packed without a Gemfile.lock
+        settings.delete('BUNDLE_FROZEN') if config.bundler[:frozen] == false || !File.exist?(config.bundler[:lockfile].to_s)
+        settings.to_yaml
+      end
 
       def bundler_specs
         bundle_without = config.bundle_without.map { |s| s.to_sym }
         definition = ::Bundler.definition
-        all = definition.specs.to_a
         requested_groups = definition.groups - bundle_without
-        requested = requested_groups.empty? ? [] : definition.specs_for(requested_groups).to_a
-        excluded_git_specs = (all - requested).select { |spec| ::Bundler::Source::Git === spec.source }
-        excluded_git_specs.each { |spec| spec.groups << :warbler_excluded }
-        requested + excluded_git_specs
+        requested_groups.empty? ? [] : definition.specs_for(requested_groups).to_a
       end
 
       def bundler_source_is_warbled_gem_itself?(source)

data/lib/warbler/traits/jar.rb

@@ -32,10 +32,6 @@ module Warbler
         config.init_contents << "#{config.warbler_templates}/jar.erb"
       end
 
-      def after_configure
-        config.init_contents << StringIO.new("require 'rubygems' unless defined?(Gem)\n")
-      end
-
       def update_archive(jar)
         unless config.manifest_file
           manifest = Warbler::Jar::DEFAULT_MANIFEST.chomp + "Main-Class: JarMain\n"

data/lib/warbler/version.rb

@@ -6,5 +6,5 @@
 #++
 
 module Warbler
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 end

data/warble.rb

@@ -21,7 +21,7 @@
 # Configure a new Warbler application assembly
 Warbler::Config.new(forced_traits: defined?(forced_traits) ? forced_traits : nil) do |config|
   # Features: additional options controlling how the jar is built.
-  # Currently the following features are supported:
+  # Currently, the following features are supported:
   # - *gemjar*: package the gem repository in a jar file in WEB-INF/lib
   # - *executable*: embed a web server and make the war executable
   # - *runnable*: allows to run bin scripts e.g. `java -jar my.war -S rake -T`
@@ -101,7 +101,7 @@ Warbler::Config.new(forced_traits: defined?(forced_traits) ? forced_traits : nil
   # File extension for the archive. Defaults to either 'jar' or 'war'.
   # config.jar_extension = "jar"
 
-  # Destionation for the created archive. Defaults to project's root directory.
+  # Destination for the created archive. Defaults to project's root directory.
   # config.autodeploy_dir = "dist/"
 
   # Name of the MANIFEST.MF template for the war file. Defaults to a simple
@@ -120,9 +120,9 @@ Warbler::Config.new(forced_traits: defined?(forced_traits) ? forced_traits : nil
   # When set it specify the bytecode version for compiled class files
   # config.bytecode_version = "1.8"
 
-  # When set to true, Warbler will override the value of ENV['GEM_HOME'] even it
-  # has already been set. When set to false it will use any existing value of
-  # GEM_HOME if it is set.
+  # When set to true, Warbler will override the value of ENV['GEM_HOME'] even it has already been set.
+  # When set to false it will use any existing value of GEM_HOME if it is set. It's usually a bad idea to disable this;
+  # your built application will not be self-contained/isolated from the wider RubyGems environment of the machine.
   # config.override_gem_home = true
 
   # Specify executable

data/warbler.gemspec

@@ -33,7 +33,7 @@ bundle up all of your application files for deployment to a Java environment.}
   gem.add_runtime_dependency 'rake', ['~> 13.0', '>= 13.0.3']
   gem.add_runtime_dependency 'rexml', '~> 3.0'
   gem.add_runtime_dependency 'jruby-jars', ['>= 9.4', '< 10.2']
-  gem.add_runtime_dependency 'jruby-rack', ['>= 1.2.7', '< 1.4']
+  gem.add_runtime_dependency 'jruby-rack', ['>= 1.2.7', '< 2.1']
   gem.add_runtime_dependency 'rubyzip', ['>= 2.1.0', '< 4']
   gem.add_runtime_dependency 'ostruct', '~> 0.6.2'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: warbler
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Nick Sieger
@@ -72,7 +72,7 @@ dependencies:
         version: 1.2.7
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -82,7 +82,7 @@ dependencies:
         version: 1.2.7
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement