ji2p 0.0.3-java

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/gem_installer.rb

@@ -0,0 +1,89 @@
+
+require "pathname"
+require "rubygems/package"
+require "fileutils"
+
+require_relative 'environment.rb'
+
+module Ji2p
+  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

data/lib/ji2p/jar_dependencies.rb

@@ -0,0 +1,15 @@
+require "jar_dependencies"
+
+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
+

data/lib/ji2p/proxy_support.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require "uri"
+require "java"
+require "erb"
+
+module Ji2p
+  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

data/lib/ji2p/rspec.rb

@@ -0,0 +1,16 @@
+require_relative 'environment'
+Ji2p::Bundler.setup!({:without => [:build]})
+require 'ji2p'
+
+$LOAD_PATH.unshift(File.join(Ji2p::Environment::JI2P_CORE, "spec"))
+
+require 'rspec/core'
+require 'rspec'
+
+RSpec.world.reset # if multiple rspec runs occur in a single process, the RSpec "world" state needs to be reset.
+
+status = RSpec::Core::Runner.run(ARGV.empty? ? ($JUNIT_ARGV || ["spec"]) : ARGV).to_i
+if ENV["IS_JUNIT_RUN"]
+  return status
+end
+exit status if status != 0

data/lib/ji2p/server.rb

@@ -0,0 +1,10 @@
+module Ji2p
+  module Server
+    autoload :Api, File.expand_path('server/api.rb', __dir__)
+    autoload :Database, File.expand_path('server/database.rb', __dir__)
+    autoload :HTTP, File.expand_path('server/http.rb', __dir__)
+    autoload :HttpServer, File.expand_path('server/http_server.rb', __dir__)
+    autoload :Launcher, File.expand_path('server/launcher.rb', __dir__)
+    autoload :Models, File.expand_path('server/models.rb', __dir__)
+  end
+end

data/lib/ji2p/server/api.rb

@@ -0,0 +1,14 @@
+require 'sinatra'
+require 'rack'
+require 'puma'
+
+module Ji2p::Server
+  class Api
+    def initialize
+      configure { set :server, :puma }
+
+      #Faye::WebSocket.load_adapter('puma')
+      @puma = Rack::Handler.get('puma')
+    end
+  end
+end

data/lib/ji2p/server/database.rb

@@ -0,0 +1,66 @@
+require 'active_record'
+
+module Ji2p::Server
+  module Database
+    @@connections = Hash.new
+    @@default_connection = nil
+
+    def self.connect! db=':memory:', db_type='sqlite3'
+      conn = ActiveRecord::Base.establish_connection(database: db, adapter: db_type)
+      key = "#{db}/#{db_type}/#{Ji2p::Control.unique_id.to_s}"
+      @@connections[key] = conn
+      @@default_connection = conn if @@default_connection.nil?
+      define_state_schema!
+      conn
+    end
+
+    def self.connect_with_local_path! name
+      java_import 'net.i2p.I2PAppContext'
+      ctx = Java::NetI2p::I2PAppContext.getGlobalContext
+      path = File.join ctx.getConfigDir.toString, name
+      connect! path
+    end
+
+    def self.flush
+      @@default_connection.flush
+    end
+
+    def self.default
+      @@default_connection
+    end
+
+    def self.is_connected?
+      get_connections.size > 0
+    end
+
+    def self.get_connections
+      @@connections
+    end
+
+    def self.define_state_schema! b_force=false
+      ActiveRecord::Schema.define do
+        create_table :keypairs, force: b_force do |t|
+          t.string   :strid
+          t.string   :name
+          t.text     :destination
+          t.string   :base32
+          t.text     :private_key_data
+          t.json     :metadata
+          t.timestamps
+        end unless ActiveRecord::Base.connection.table_exists? 'keypairs' or b_force
+        create_table :tunnels, force: b_force do |t|
+          t.string     :name
+          t.text       :description
+          t.json       :metadata
+          t.references :keypair
+          t.string     :tunnel_type
+          t.integer    :listen_port
+          t.integer    :target_port
+          t.string     :listen_interface
+          t.string     :target_host
+          t.timestamps
+        end unless ActiveRecord::Base.connection.table_exists? 'tunnels' or b_force
+      end
+    end
+  end
+end