ji2p-base 0.0.5-universal-java-11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a3309d89cdb124ccae61ce85f5b93e8962b36bbabc465b6a50f40b79d81eeb63
+  data.tar.gz: 04cb540e79eaea6fcfb299d4d8fa104e8342bf2f0b23b4661b3f3c1c17469306
+SHA512:
+  metadata.gz: 36b4987adaf56340996556898eb9236bb1567a0b3ea5dc4db2b4e27fb83eef98f1ac68a3c01af5646b98a94fa80bd5a9428d8e1a1f31b4a00d1597e7e1b88053
+  data.tar.gz: 72e63765ae2436be82e5f59ee2636ecafa3fb4b51dbbf98b0aec01f4768e5452c9c77d4dad6301a7e732fd3534147fd502efe7be05b49360e46a2c71b12ea894

data/lib/core_ext.rb

@@ -0,0 +1,57 @@
+
+class Hash
+  def to_properties
+    # Java::JavaUtil::Properties
+    props = java_import('java.util.Properties').first.new
+    self.each do |k,v|
+      props[k.to_s] = v.to_s
+    end
+    props
+  end
+
+  def self.from_properties props,convert_symbols=false
+    return unless props.is_a? java_import('java.util.Properties').first
+    hash = new
+    props.each do |k,v|
+      k = k.to_sym if convert_symbols
+      hash[k] = v
+    end
+    hash
+  end
+end
+
+class Object
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      public_send(*a, &b) if respond_to?(a.first)
+    end
+  end
+end
+
+class NilClass
+  def try(*args)
+    nil
+  end
+
+  #def method_missing(method, *args)
+  #  nil
+  #end
+end
+
+class String #:nodoc:
+
+  unless method_defined?(:ascii_only?)
+    # Backport from Ruby 1.9 checks for non-us-ascii characters.
+    def ascii_only?
+      self !~ MATCH_NON_US_ASCII
+    end
+
+    MATCH_NON_US_ASCII = /[^\x00-\x7f]/
+  end
+
+  unless method_defined?(:bytesize)
+    alias :bytesize :length
+  end
+end

data/lib/gen_server.rb

@@ -0,0 +1,57 @@
+require "ostruct"
+require "securerandom"
+
+module GenServer
+  class << self
+    def call(pid, method, *args)
+      entry = fetch_entry(pid)
+      value, state = entry.module.send(method, entry.state, *args)
+      entry.state = state
+      update_entry(pid, entry)
+      value
+    end
+
+    def cast(pid, method, *args)
+      entry = fetch_entry(pid)
+      entry.state = entry.module.send(method, entry.state, *args)
+      update_entry(pid, entry)
+      nil
+    end
+
+    def start_link(mod, *args)
+      state = mod.init(*args)
+      add_entry(mod, state)
+    end
+
+    def terminate(pid)
+      remove_entry(pid)
+    end
+
+    private
+
+    def add_entry(mod, state)
+      SecureRandom.uuid.tap do |uuid|
+        entries[uuid] = OpenStruct.new(
+          :module => mod,
+          :state => state
+        )
+      end
+    end
+
+    def entries
+      @entries ||= {}
+    end
+
+    def fetch_entry(pid)
+      entries[pid]
+    end
+
+    def remove_entry(pid)
+      entries.delete(pid)
+    end
+
+    def update_entry(pid, entry)
+      entries[pid] = entry
+    end
+  end
+end

data/lib/ji2p.rb

@@ -0,0 +1,26 @@
+require 'logger'
+require 'java'
+$CLASSPATH << "file:///#{File.expand_path(File.join(__dir__, '..', 'config'))}/"
+
+require 'ji2p/environment.rb'
+
+module Ji2p
+  require_relative 'ji2p/version.rb'
+
+  # https://github.com/jruby/jruby/wiki/RedBridge
+  java_import 'java.lang.System'
+  System.setProperty("org.jruby.embed.localcontext.scope", "singleton") # concurrent, threadsafe, etc.
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.disable_crypto_restriction
+    # java.lang.Class.for_name('javax.crypto.JceSecurity').get_declared_field('isRestricted').tap{|f| f.accessible = true; f.set nil, false}
+    security_class = java.lang.Class.for_name('javax.crypto.JceSecurity')
+    restricted_field = security_class.get_declared_field('isRestricted')
+    restricted_field.accessible = true
+    restricted_field.set nil, false
+  end
+
+end

data/lib/ji2p/bundler.rb

@@ -0,0 +1,165 @@
+require 'fileutils'
+
+module Ji2p
+  module Bundler
+    extend self
+
+    def setup!(options = {})
+      options = {:without => [:development]}.merge(options)
+      options[:without] = Array(options[:without])
+
+      ::Gem.clear_paths
+      ENV['GEM_HOME'] = ENV['GEM_PATH'] = Environment.ji2p_gem_home
+      ::Gem.paths = ENV
+
+      # set BUNDLE_GEMFILE ENV before requiring bundler to avoid bundler recurse and load unrelated Gemfile(s)
+      ENV["BUNDLE_GEMFILE"] = Environment::GEMFILE_PATH
+
+      require 'bundler'
+
+      ::Bundler.settings.set_local(:path, Environment::BUNDLE_DIR)
+      ::Bundler.settings.set_local(:without, options[:without])
+      # in the context of Bundler.setup it looks like this is useless here because Gemfile path can only be specified using
+      # the ENV, see https://github.com/bundler/bundler/blob/v1.8.3/lib/bundler/shared_helpers.rb#L103
+      ::Bundler.settings.set_local(:gemfile, Environment::GEMFILE_PATH)
+
+      ::Bundler.reset!
+      ::Bundler.setup
+    end
+
+    # execute bundle install and capture any $stdout output. any raised exception in the process will be trapped
+    # and returned. logs errors to $stdout.
+    # @param [Hash] options invoke options with default values, :max_tries => 10, :clean => false, :install => false, :update => false
+    # @option options [Boolean] :max_tries The number of times bundler is going to try the installation before failing (default: 10)
+    # @option options [Boolean] :clean It cleans the unused gems (default: false)
+    # @option options [Boolean] :install Run the installation of a set of gems defined in a Gemfile (default: false)
+    # @option options [Boolean, String, Array] :update Update the current environment, must be either false or a String or an Array of String (default: false)
+    # @option options [Boolean] :local Do not attempt to fetch gems remotely and use the gem cache instead (default: false)
+    # @option options [Boolean] :package Locks and then caches all dependencies to be reused later on (default: false)
+    # @option options [Boolean] :all It packages dependencies defined with :git or :path (default: false)
+    # @option options [Array] :without  Exclude gems that are part of the specified named group (default: [:development])
+    # @return [String, Exception] the installation captured output and any raised exception or nil if none
+    def invoke!(options = {})
+      options = {:max_tries => 10, :clean => false, :install => false, :update => false, :local => false,
+                 :jobs => 12, :all => false, :package => false, :without => [:development]}.merge(options)
+      options[:without] = Array(options[:without])
+      options[:update] = Array(options[:update]) if options[:update]
+
+      ::Gem.clear_paths
+      ENV['GEM_HOME'] = ENV['GEM_PATH'] = Ji2p::Environment.ji2p_gem_home
+      ::Gem.paths = ENV
+      # set BUNDLE_GEMFILE ENV before requiring bundler to avoid bundler recurse and load unrelated Gemfile(s).
+      # in the context of calling Bundler::CLI this is not really required since Bundler::CLI will look at
+      # Bundler.settings[:gemfile] unlike Bundler.setup. For the sake of consistency and defensive/future proofing, let's keep it here.
+      ENV["BUNDLE_GEMFILE"] = Ji2p::Environment::GEMFILE_PATH
+
+      require 'bundler'
+      require 'bundler/cli'
+
+      # force Rubygems sources to our Gemfile sources
+      ::Gem.sources = ::Gem::SourceList.from(options[:rubygems_source]) if options[:rubygems_source]
+
+      ::Bundler.settings.set_local(:path, Ji2p::Environment::BUNDLE_DIR)
+      ::Bundler.settings.set_local(:gemfile, Ji2p::Environment::GEMFILE_PATH)
+      ::Bundler.settings.set_local(:without, options[:without])
+      ::Bundler.settings.set_local(:force, options[:force])
+
+      if !debug?
+        # Will deal with transient network errors
+        execute_bundler_with_retry(options)
+      else
+        options[:verbose] = true
+        execute_bundler(options)
+      end
+    end
+
+    def execute_bundler_with_retry(options)
+      try = 0
+      # capture_stdout also traps any raised exception and pass them back as the function return [output, exception]
+      output, exception = capture_stdout do
+        loop do
+          begin
+            execute_bundler(options)
+            break
+          rescue ::Bundler::VersionConflict => e
+            $stderr.puts("Plugin version conflict, aborting")
+            raise(e)
+          rescue ::Bundler::GemNotFound => e
+            $stderr.puts("Plugin not found, aborting")
+            raise(e)
+          rescue => e
+            if try >= options[:max_tries]
+              $stderr.puts("Too many retries, aborting, caused by #{e.class}")
+              $stderr.puts(e.message) if ENV["DEBUG"]
+              raise(e)
+            end
+
+            try += 1
+            $stderr.puts("Error #{e.class}, retrying #{try}/#{options[:max_tries]}")
+            $stderr.puts(e.message)
+            sleep(0.5)
+          end
+        end
+      end
+      raise exception if exception
+
+      return output
+    end
+
+    def execute_bundler(options)
+      ::Bundler.reset!
+      ::Bundler::CLI.start(bundler_arguments(options))
+    end
+
+    def debug?
+      ENV["DEBUG"]
+    end
+
+    # build Bundler::CLI.start arguments array from the given options hash
+    # @param option [Hash] the invoke! options hash
+    # @return [Array<String>] Bundler::CLI.start string arguments array
+    def bundler_arguments(options = {})
+      arguments = []
+
+      if options[:install]
+        arguments << "install"
+        arguments << "--clean" if options[:clean]
+        if options[:local]
+          arguments << "--local"
+          arguments << "--no-prune" # From bundler docs: Don't remove stale gems from the cache.
+        end
+      elsif options[:update]
+        arguments << "update"
+        arguments << options[:update]
+        arguments << "--local" if options[:local]
+      elsif options[:clean]
+        arguments << "clean"
+      elsif options[:package]
+        arguments << "package"
+        arguments << "--all" if options[:all]
+      end
+
+      arguments << "--verbose" if options[:verbose]
+
+      arguments.flatten
+    end
+
+    # capture any $stdout from the passed block. also trap any exception in that block, in which case the trapped exception will be returned
+    # @param [Proc] the code block to execute
+    # @return [String, Exception] the captured $stdout string and any trapped exception or nil if none
+    def capture_stdout(&block)
+      old_stdout = $stdout
+      $stdout = StringIO.new("", "w")
+      begin
+        block.call
+      rescue => e
+        return [$stdout.string, e]
+      end
+
+      [$stdout.string, nil]
+    ensure
+      $stdout = old_stdout
+    end
+
+  end
+end

data/lib/ji2p/environment.rb

@@ -0,0 +1,35 @@
+require 'pathname'
+
+module Ji2p
+  module Environment
+    extend self
+    JI2P_HOME = ::File.expand_path(::File.join('..','..'), __dir__) unless defined? JI2P_HOME
+
+    BUNDLE_DIR = ::File.join(JI2P_HOME, "vendor", "bundle") unless defined? BUNDLE_DIR
+    GEMFILE_PATH = ::File.join(JI2P_HOME, "Gemfile") unless defined? GEMFILE_PATH
+    LOCAL_GEM_PATH = ::File.join(JI2P_HOME, 'vendor', 'local_gems') unless defined? LOCAL_GEM_PATH
+    CACHE_PATH = ::File.join(JI2P_HOME, "vendor", "cache") unless defined? CACHE_PATH
+    LOCKFILE = Pathname.new(::File.join(JI2P_HOME, "Gemfile.lock")) unless defined? LOCKFILE
+    GEMFILE = Pathname.new(::File.join(JI2P_HOME, "Gemfile")) unless defined? GEMFILE
+
+    def gem_ruby_version
+      RbConfig::CONFIG["ruby_version"]
+    end
+
+    def ruby_abi_version
+      RUBY_VERSION[/(\d+\.\d+)(\.\d+)*/, 1]
+    end
+
+    def ruby_engine
+      RUBY_ENGINE
+    end
+
+    def ji2p_gem_home
+      ::File.join(BUNDLE_DIR, ruby_engine, gem_ruby_version)
+    end
+
+    def vendor_path(path)
+      return ::File.join(JI2P_HOME, "vendor", path)
+    end
+  end
+end

data/lib/ji2p/package/gem_installer.rb

@@ -0,0 +1,91 @@
+
+require "pathname"
+require "rubygems/package"
+require "fileutils"
+
+require_relative 'environment.rb'
+
+module Ji2p
+  module Package
+    class GemInstaller
+      GEM_HOME = Pathname.new(::File.join(Ji2p::Environment::BUNDLE_DIR, "jruby", "2.5.0"))
+      SPECIFICATIONS_DIR = "specifications"
+      GEMS_DIR = "gems"
+      CACHE_DIR = "cache"
+
+      attr_reader :gem_home
+
+      def initialize(gem_file, display_post_install_message = false, gem_home = GEM_HOME)
+        @gem_file = gem_file
+        @gem = ::Gem::Package.new(@gem_file)
+        @gem_home = Pathname.new(gem_home)
+        @display_post_install_message = display_post_install_message
+      end
+
+      def install
+        create_destination_folders
+        extract_files
+        write_specification
+        copy_gem_file_to_cache
+        post_install_message
+      end
+
+      def self.install(gem_file, display_post_install_message = false, gem_home = GEM_HOME)
+        self.new(gem_file, display_post_install_message, gem_home).install
+      end
+
+      private
+      def spec
+        @gem.spec
+      end
+
+      def spec_dir
+        gem_home.join(SPECIFICATIONS_DIR)
+      end
+
+      def cache_dir
+        gem_home.join(CACHE_DIR)
+      end
+
+      def spec_file
+        spec_dir.join("#{spec.full_name}.gemspec")
+      end
+
+      def gem_dir
+        gem_home.join(GEMS_DIR, spec.full_name)
+      end
+
+      def extract_files
+        @gem.extract_files gem_dir
+      end
+
+      def write_specification
+        ::File.open(spec_file, 'w') do |file|
+          spec.installed_by_version = ::Gem.rubygems_version
+          file.puts spec.to_ruby_for_cache
+          file.fsync rescue nil # Force writing to disk
+        end
+      end
+
+      def post_install_message
+        spec.post_install_message if display_post_install_message?
+      end
+
+      def display_post_install_message?
+        @display_post_install_message && !spec.post_install_message.nil?
+      end
+
+      def copy_gem_file_to_cache
+        destination = ::File.join(cache_dir, ::File.basename(@gem_file))
+        FileUtils.cp(@gem_file, destination)
+      end
+
+      def create_destination_folders
+        FileUtils.mkdir_p(gem_home)
+        FileUtils.mkdir_p(gem_dir)
+        FileUtils.mkdir_p(spec_dir)
+        FileUtils.mkdir_p(cache_dir)
+      end
+    end
+  end
+end

data/lib/ji2p/package/gemfile.rb

@@ -0,0 +1,234 @@
+module Ji2p
+  module Package
+    class GemfileError < StandardError; end
+
+    class Gemfile
+      attr_accessor :gemset
+
+      HEADER = \
+        "# This is a Logstash generated Gemfile.\n" + \
+        "# If you modify this file manually all comments and formatting will be lost.\n\n"
+
+      # @params io [IO] any IO object that supports read, write, truncate, rewind
+      def initialize(io)
+        @io = io
+        @gemset = nil
+      end
+
+      def load(with_backup = true)
+        # encoding must be set to UTF-8 here to avoid ending up with Windows-1252 encoding on Windows
+        # which will break the DSL instance_eval of that string
+        @io.set_encoding(Encoding::UTF_8)
+        @gemset ||= DSL.parse(@io.read)
+        backup if with_backup
+        self
+      end
+
+      def save
+        raise(GemfileError, "a Gemfile must first be loaded") unless @gemset
+        @io.truncate(0)
+        @io.rewind
+        @io.write(generate)
+        @io.flush
+      end
+
+      def generate
+        "#{HEADER}#{gemset.to_s}"
+      end
+
+      def find(name)
+        @gemset.find_gem(name)
+      end
+
+      # @param name [String] gem name
+      # @param *requirements params following name use the same notation as the Gemfile gem DSL statement
+      # @raise GemfileError if gem already exists in Gemfile
+      def add(name, *requirements)
+        @gemset.add_gem(Gem.parse(name, *requirements))
+      end
+
+      # update existing or add new and merge passed options with current gem options if it exists
+      # @param name [String] gem name
+      # @param *requirements params following name use the same notation as the Gemfile gem DSL statement
+      def update(name, *requirements)
+        @gemset.update_gem(Gem.parse(name, *requirements))
+      end
+
+      # overwrite existing or add new
+      # @param name [String] gem name
+      # @param *requirements params following name use the same notation as the Gemfile gem DSL statement
+      def overwrite(name, *requirements)
+        @gemset.overwrite_gem(Gem.parse(name, *requirements))
+      end
+
+      # @return [Gem] removed gem or nil if not found
+      def remove(name)
+        @gemset.remove_gem(name)
+      end
+
+      def backup
+        @original_backup = @gemset.copy
+      end
+
+      def restore
+        @gemset = @original_backup
+      end
+
+      def defined_in_gemfile?(name)
+        @gemset.find_gem(name)
+      end
+
+      def restore!
+        restore
+        save
+      end
+
+      def locally_installed_gems
+        @gemset.gems.select { |gem| gem.options.include?(:path) }
+      end
+    end
+
+    class Gemset
+      attr_accessor :sources, :gems, :gemspec
+
+      def initialize
+        @sources = []      # list of urls
+        @gems = []         # list of Gem class
+        @gems_by_name = {} # hash of name => Gem
+        @gemspec = {}      # gemspec is a options hash
+      end
+
+      def to_s
+        [sources_to_s, gemspec_to_s, gems_to_s].select{|s| !s.empty?}.join("\n") + "\n"
+      end
+
+      # @return [Gem] found gem or nil if not found
+      def find_gem(name)
+        @gems_by_name[name.downcase]
+      end
+
+      # @raise GemfileError if gem already exists
+      def add_gem(_gem)
+        raise(GemfileError, "duplicate gem #{_gem.name}") if find_gem(_gem.name)
+        @gems << _gem
+        @gems_by_name[_gem.name.downcase] = _gem
+      end
+
+      # update existing or add new
+      def update_gem(_gem)
+        if old = find_gem(_gem.name)
+          # always overwrite requirements if specified
+          old.requirements = _gem.requirements unless no_constrains?(_gem.requirements)
+          # but merge options
+          old.options = old.options.merge(_gem.options)
+        else
+          @gems << _gem
+          @gems_by_name[_gem.name.downcase] = _gem
+        end
+      end
+
+      # update existing or add new
+      def overwrite_gem(_gem)
+        if old = find_gem(_gem.name)
+          @gems[@gems.index(old)] = _gem
+        else
+          @gems << _gem
+        end
+        @gems_by_name[_gem.name.downcase] = _gem
+      end
+
+      # @return [Gem] removed gem or nil if not found
+      def remove_gem(name)
+        if _gem = @gems_by_name.delete(name.downcase)
+          @gems.delete_at(@gems.index(_gem))
+        end
+        _gem
+      end
+
+      # deep clone self
+      def copy
+        Marshal.load(Marshal.dump(self))
+      end
+
+      private
+
+      def no_constrains?(requirements)
+        return true if requirements.nil? || requirements.empty?
+
+        # check for the dummy ">= 0" version constrain or any variations thereof
+        # which is in fact a "no constrain" constrain which we should discard
+        return true if requirements.size == 1 && requirements.first.to_s.gsub(/\s+/, "") == ">=0"
+
+        false
+      end
+
+      def sources_to_s
+        return "" if @sources.empty?
+        @sources.map{|source| "source #{source.inspect}"}.join("\n")
+      end
+
+      def gems_to_s
+        return "" if @gems.empty?
+        @gems.map do |gem|
+          requirements = gem.requirements.empty? ? nil : gem.requirements.map{|r| r.inspect}.join(", ")
+          options = gem.options.empty? ? nil : gem.options.map{|k, v| "#{k.inspect} => #{v.inspect}"}.join(", ")
+          "gem " + [gem.name.inspect, requirements, options].compact.join(", ")
+        end.join("\n")
+      end
+
+      def gemspec_to_s
+        return "" if @gemspec.empty?
+        options = @gemspec.map{|k, v| "#{k.inspect} => #{v.inspect}"}.join(", ")
+        "gemspec #{options}"
+      end
+    end
+
+    # DSL is a minimal, incomplete Gemfile DSL subset parser, only what is currently required is implemented.
+    class DSL
+      attr_reader :gemset
+
+      def initialize
+        @gemset = Gemset.new
+      end
+
+      # @param gemfile_content [String] the Gemfile string content
+      # @return [Gemset] parsed Gemfile content as a Gemset
+      def self.parse(gemfile_content)
+        dsl = self.new
+        dsl.instance_eval(gemfile_content)
+        dsl.gemset
+      end
+
+      # DSL methods
+
+      def source(url)
+        @gemset.sources << url
+      end
+
+      def gem(name, *requirements)
+        parsed = Gem.parse(name, *requirements)
+        @gemset.add_gem(parsed)
+      end
+
+      def gemspec(options = {})
+        raise(GemfileError, "cannot declare multiple gemspec directives") unless @gemset.gemspec.empty?
+        @gemset.gemspec = options
+      end
+    end
+
+    class Gem
+      attr_accessor :name, :requirements, :options
+
+      def initialize(name, requirements = [], options = {})
+        @name = name
+        @requirements = requirements.map{|r| r.to_s.strip}.select{|r| !r.empty?}
+        @options = options
+      end
+
+      def self.parse(name, *requirements)
+        options = requirements.last.is_a?(Hash) ? requirements.pop : {}
+        self.new(name, requirements, options)
+      end
+    end
+  end
+end

data/lib/ji2p/package/jar_dependencies.rb

@@ -0,0 +1,23 @@
+require "jar_dependencies"
+
+module Ji2p
+  module Package
+    module JarDependencies
+      extend self
+
+      def require_jar( *args )
+        return nil unless Jars.require?
+        result = Jars.require_jar( *args )
+        if result.is_a? String
+          # JAR_DEBUG=1 will now show theses
+          Jars.debug { "--- jar coordinate #{args[0..-2].join( ':' )} already loaded with version #{result} - omit version #{args[-1]}" }
+          Jars.debug { "    try to load from #{caller.join("\n\t")}" }
+          return false
+        end
+        Jars.debug { "    register #{args.inspect} - #{result == true}" }
+        result
+      end
+    end
+  end
+end
+

data/lib/ji2p/package/proxy_support.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require "uri"
+require "java"
+require "erb"
+
+module Ji2p
+  module Package
+    module ProxySupport
+      extend self
+
+      # Apply HTTP_PROXY and HTTPS_PROXY to the current environment
+      # this will be used by any JRUBY calls
+      def apply_env_proxy_settings(settings)
+        $stderr.puts("Using proxy #{settings}") if ENV["DEBUG"]
+        scheme = settings[:protocol].downcase
+        java.lang.System.setProperty("#{scheme}.proxyHost", settings[:host])
+        java.lang.System.setProperty("#{scheme}.proxyPort", settings[:port].to_s)
+        java.lang.System.setProperty("#{scheme}.proxyUsername", settings[:username].to_s)
+        java.lang.System.setProperty("#{scheme}.proxyPassword", settings[:password].to_s)
+      end
+
+      def extract_proxy_values_from_uri(proxy_uri)
+        {
+          :protocol => proxy_uri.scheme,
+          :host => proxy_uri.host,
+          :port => proxy_uri.port,
+          :username => proxy_uri.user,
+          :password => proxy_uri.password
+        }
+      end
+
+      def parse_proxy_string(proxy_string)
+        proxy_uri = URI.parse(proxy_string)
+        if proxy_uri.kind_of?(URI::HTTP) # URI::HTTPS is already a subclass of URI::HTTP
+          proxy_uri
+        else
+          raise "Invalid proxy `#{proxy_uri}`. The URI is not HTTP/HTTPS."
+        end
+      end
+
+      def get_proxy(key)
+        ENV[key.downcase] || ENV[key.upcase]
+      end
+
+      def proxy_string_exists?(proxy)
+        !proxy.nil? && !proxy.strip.empty?
+      end
+    end
+  end
+end

data/lib/ji2p/utils/blocking_queue.rb

@@ -0,0 +1,32 @@
+require 'thread'
+
+module Ji2p
+  module Utils
+    class BlockingQueue
+      attr_reader :queue, :mutex, :cv
+
+      def initialize
+        @queue = Array.new
+        @mutex = Mutex.new
+        @cv    = ConditionVariable.new
+      end
+
+      def push(ele)
+        @mutex.synchronize do
+          @queue.push ele
+          @cv.signal
+        end
+      end
+
+      def pop
+        @mutex.synchronize do
+          while @queue.empty?
+            @cv.wait(@mutex)
+          end
+
+          @queue.pop
+        end
+      end
+    end
+  end
+end

data/lib/ji2p/utils/byte_value.rb

@@ -0,0 +1,61 @@
+module Ji2p
+  module Utils
+    module ByteValue
+      module_function
+
+      B = 1
+      KB = B << 10
+      MB = B << 20
+      GB = B << 30
+      TB = B << 40
+      PB = B << 50
+
+      def parse(text)
+        if !text.is_a?(String)
+          raise ArgumentError, "ByteValue::parse takes a String, got a `#{text.class.name}`"
+        end
+        number = text.to_f
+        factor = multiplier(text)
+
+        (number * factor).to_i
+      end
+
+      def multiplier(text)
+        case text
+          when /(?:k|kb)$/
+            KB
+          when /(?:m|mb)$/
+            MB
+          when /(?:g|gb)$/
+            GB
+          when /(?:t|tb)$/
+            TB
+          when /(?:p|pb)$/
+            PB
+          when /(?:b)$/
+            B
+          else
+            raise ArgumentError, "Unknown bytes value '#{text}'"
+        end
+      end
+
+      def human_readable(number)
+        value, unit = if number > PB
+          [number / PB, "pb"]
+        elsif number > TB
+          [number / TB, "tb"]
+        elsif number > GB
+          [number / GB, "gb"]
+        elsif number > MB
+          [number / MB, "mb"]
+        elsif number > KB
+          [number / KB, "kb"]
+        else
+          [number, "b"]
+        end
+
+        format("%.2d%s", value, unit)
+      end
+    end
+  end
+end

data/lib/ji2p/version.rb

@@ -0,0 +1,3 @@
+module Ji2p
+  VERSION = '0.0.5'.freeze unless defined? VERSION
+end

data/lib/maybe.rb

@@ -0,0 +1,148 @@
+class Object
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      public_send(*a, &b) if respond_to?(a.first)
+    end
+  end
+end
+
+class NilClass
+  def try(*args)
+    nil
+  end
+
+  #def method_missing(method, *args)
+  #  nil
+  #end
+end
+
+Optional = Struct.new(:value) do
+  def and_then(&block)
+    if value.nil?
+      Optional.new(nil)
+    else
+      block.call(value)
+    end
+  end
+
+  def method_missing(*args, &block)
+    and_then do |value|
+      Optional.new(value.public_send(*args, &block))
+    end
+  end
+end
+
+Many = Struct.new(:values) do
+  def and_then(&block)
+    Many.new(
+      values.map(&block).flat_map(&:values)
+    )
+  end
+end
+
+Eventually = Struct.new(:block) do
+  def and_then(&block)
+    Eventually.new do |success|
+      run do |value|
+        block.call(value).run(&success)
+      end
+    end
+  end
+end
+
+module Monad
+  def within(&block)
+    and_then do |value|
+      self.class.from_value(block.call(value))
+    end
+  end
+end
+
+Optional.include(Monad)
+Many.include(Monad)
+Eventually.include(Monad)
+
+
+class Maybe
+  class Some
+  end
+  class None
+  end
+end
+
+module Functional
+  extend self
+  class Option
+    (Enumerable.instance_methods << :each).each do |enumerable_method|
+      define_method(enumerable_method) do |*args, &block|
+        res = enumerable_value.send(enumerable_method, *args, &block)
+        res.respond_to?(:each) ? Option(res.first) : res
+      end
+    end
+
+    alias_method :enumerable_value, :to_a
+  end
+
+  def Option(value)
+    if value.nil? || (value.respond_to?(:length) && value.length == 0)
+      None()
+    else
+      Some(value)
+    end
+  end
+
+  class None < Option
+    def get
+      fail 'No such element'
+    end
+
+    def or_else(default = nil)
+      block_given? ? yield : default
+    end
+
+    def method_missing(*)
+      self
+    end
+
+    private
+    def enumerable_value
+      []
+    end
+  end
+
+  def None
+    None.new
+  end
+
+  class Some < Option
+    def initialize(value)
+      @value = value
+    end
+
+    def get
+      value
+    end
+
+    def or_else(*)
+      value
+    end
+
+    def method_missing(method_sym, *args, &block)
+      map { |value| value.send(method_sym, *args, &block) }
+    end
+
+    private
+    attr_reader :value
+
+    def enumerable_value
+      [value]
+    end
+  end
+
+  def Some(value)
+    Some.new(value)
+  end
+end
+

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: ji2p-base
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: universal-java-11
+authors:
+- Mikal Villa
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2019-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  name: bundler
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  name: httparty
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: jar-dependencies
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  name: rake
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  name: warbler
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: awesome_print
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  name: ruby-maven
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: JRuby interface for I2P
+email: mikalv@mikalv.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/core_ext.rb
+- lib/gen_server.rb
+- lib/ji2p.rb
+- lib/ji2p/bundler.rb
+- lib/ji2p/environment.rb
+- lib/ji2p/package/gem_installer.rb
+- lib/ji2p/package/gemfile.rb
+- lib/ji2p/package/jar_dependencies.rb
+- lib/ji2p/package/proxy_support.rb
+- lib/ji2p/utils/blocking_queue.rb
+- lib/ji2p/utils/byte_value.rb
+- lib/ji2p/version.rb
+- lib/maybe.rb
+homepage: https://github.com/mikalv/ji2p
+licenses:
+- Apache-2.0
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: Thanks for installing!
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- jar net.i2p, i2p, 0.9.43
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: JRuby interface for I2P
+test_files: []