ji2p 0.0.3-jruby-java-universal-java-9

data/lib/ji2p/control/socket_manager.rb

@@ -0,0 +1,77 @@
+require 'java'
+require 'thread'
+require_relative 'server.rb'
+
+module Ji2p::Control
+  java_import 'net.i2p.I2PAppContext'
+  java_import 'net.i2p.client.I2PClientFactory'
+  java_import 'net.i2p.client.streaming.I2PSocketManager'
+  java_import 'net.i2p.client.streaming.I2PSocketManagerFactory'
+  java_import 'net.i2p.client.streaming.IncomingConnectionFilter'
+  java_import 'java.util.Properties'
+  java_import 'java.lang.Thread'
+
+  class SocketManager
+
+    def self.defineManager! name, kp, opts=Java::JavaUtil::Properties.new, filter=IncomingConnectionFilter::ALLOW
+      ctx = I2PAppContext.getGlobalContext
+      session = kp.createSession opts
+      new get_impl.new(ctx,session,opts,name,filter)
+    end
+
+    def connectTunnel
+      @smgr.getSession.connect
+    end
+
+    def myDestination
+      @smgr.getSession.myDestination
+    end
+
+    def leaseSet
+      @smgr.getSession.leaseSet
+    end
+
+    def sessionId
+      @smgr.getSession.sessionId
+    end
+
+    def supports_ls2?
+      @smgr.getSession.supports_ls2?
+    end
+
+    def is_closed?
+      @smgr.getSession.closed?
+    end
+
+    def session
+      @smgr.session
+    end
+
+    def destroy
+      @smgr.getSession.destroySession
+    end
+
+    def lookupDest dest
+      @smgr.getSession.lookupDest dest
+    end
+
+    def getServerSocket
+      SocketServer.new @smgr.getServerSocket
+    end
+
+    def raw
+      @smgr
+    end
+
+    private
+
+    def self.get_impl
+      java_import('net.i2p.client.streaming.impl.I2PSocketManagerFull').first
+    end
+
+    def initialize smgr
+      @smgr = smgr
+    end
+
+  end
+end

data/lib/ji2p/control/tunnel_manager.rb

@@ -0,0 +1,62 @@
+require 'java'
+
+require 'java'
+require 'digest/sha1'
+
+module Ji2p::Control
+  class TunnelManager
+    @@tunnelctrl = nil
+    include_package 'net.i2p'
+    include_package 'net.i2p.i2ptunnel'
+    include_package 'net.i2p.client'
+
+    def self.context
+      I2PAppContext.getGlobalContext
+    end
+
+    def self.startTunnelWithConfig conf, createPrivKey = false
+      unless ['client','httpclient','server','httpserver','sockstunnel'].include? conf['type']
+        raise ArgumentError, 'Invalid i2p tunnel type!', caller
+      end
+      tctrl = TunnelController.new conf, '', createPrivKey
+      TunnelCtrl.new tctrl, conf
+    end
+
+    def self.createNewConfig hash = Hash.new
+      props = java.util.Properties.new
+      dfl = {
+        'option.maxPosts'=>'3',
+        'option.i2cp.destination.sigType'=>'EdDSA_SHA512_Ed25519',
+        'option.i2p.streaming.limitAction'=>'http',
+        'description'=>'jruby-tunnel',
+        'interface'=>'127.0.0.1',
+        'type'=>'httpserver',
+        'option.outbound.quantity'=>'4',
+        'option.inbound.quantity'=>'4',
+        'option.postBanTime'=>'1800',
+        'targetPort'=>'8000',
+        'option.postTotalBanTime'=>'600',
+        'i2cpHost'=>'127.0.0.1',
+        'option.postCheckTime'=>'300',
+        'option.i2p.streaming.maxConnsPerHour'=>'40',
+        'option.shouldBundleReplyInfo'=>'false',
+        'option.outbound.length'=>'1',
+        'targetHost'=>'127.0.0.1',
+        'option.inbound.length'=>'1',
+        'i2cpPort'=>'7654',
+        'persistentClientKey'=>'true',
+        'option.maxTotalPosts'=>'10',
+        'option.i2p.streaming.maxConnsPerDay'=>'100',
+        'option.i2p.streaming.maxTotalConnsPerMinute'=>'25',
+        'option.i2p.streaming.maxConnsPerMinute'=>'15',
+        'name'=>'jruby-tunnel',
+        'option.i2p.streaming.maxConcurrentStreams'=>'20',
+        'privKeyFile'=>'kake.dat',
+        'listenPort'=>'8000'
+      }
+      merged = dfl.merge(hash)
+      merged.keys.each { |k| props[k.to_s] = merged[k].to_s }
+      props
+    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