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

data/lib/ji2p/startup/client_application.rb

@@ -0,0 +1,20 @@
+require 'fileutils'
+
+module Ji2p
+  module Startup
+    class ClientApplication
+      java_import 'net.i2p.I2PAppContext'
+
+      def initialize name
+        @name = name
+        @ctx = Java::NetI2p::I2PAppContext.getGlobalContext
+        FileUtils.mkdir_p plugin_path unless File.exists? plugin_path
+      end
+
+      def plugin_path
+        @proot_path ||= File.expand_path("plugins/#{@name}", @ctx.getAppDir.getAbsolutePath)
+      end
+    end
+
+  end
+end

data/lib/ji2p/startup/router_manager.rb

@@ -0,0 +1,21 @@
+require 'java'
+
+module Ji2p::Startup
+  class RouterManager
+    @@router = nil
+    include_package 'net.i2p.router'
+
+    def self.start_router!
+      @@router = RouterLaunch.main ARGV if @@router.nil?
+    end
+
+    def self.router_context
+      RouterContext.getCurrentContext
+    end
+
+    def self.get_leases
+      ctx = RouterManager.router_context
+      ctx.netDb.get_leases.to_a
+    end
+  end
+end

data/lib/ji2p/startup/sinatra_app.rb

@@ -0,0 +1,61 @@
+require 'sinatra'
+require 'sinatra/base'
+#require 'sinatra/config_file'
+require 'sinatra/contrib'
+require 'sinatra/cookies'
+require 'sinatra/json'
+require 'sinatra/namespace'
+require 'sinatra/reloader'
+#require 'sinatra/webdav'
+require 'better_errors'
+require 'binding_of_caller'
+
+module Ji2p
+  module Startup
+    class SinatraApp < Sinatra::Base
+      APP_ROOT = File.expand_path('../..', __dir__) unless defined? APP_ROOT
+
+      use Rack::Session::Cookie, :key => 'rack.session',
+                           :domain => 'localhost',
+                           :path => '/',
+                           :expire_after => 2592000, # In seconds
+                           :secret => 'kake'
+
+      set :environments, %w{development test production staging}
+      enable  :sessions, :logging
+      set :sessions, true
+      set :logging, true
+      set :server, %w[puma webrick]
+      set :app_file, __FILE__
+      set :public_folder, Proc.new { File.join(APP_ROOT, 'public') }
+      set :protection, :session => true
+      unless ENV['APP_ENV'].nil?
+        set :environment, ENV['APP_ENV']
+      else
+        set :environment, :development
+      end
+
+
+      configure :development do
+        register Sinatra::Reloader
+
+        use BetterErrors::Middleware
+        BetterErrors.application_root = APP_ROOT
+
+        set :reload_stuff, true
+      end
+
+      register Sinatra::Namespace
+      #register Sinatra::ConfigFile
+
+      helpers Sinatra::Cookies
+
+      set :show_exceptions, false
+
+      get '/' do
+        json :sinatra => { :status => 'OK', :request => request.env.to_json }
+      end
+
+    end
+  end
+end

data/lib/ji2p/startup/worker.rb

@@ -0,0 +1,63 @@
+module Ji2p
+  module Startup
+    class Worker
+      def self.start(num_threads:, queue_size:)
+        queue = SizedQueue.new(queue_size)
+        worker = new(num_threads: num_threads, queue: queue)
+        worker.spawn_threads
+        worker
+      end
+
+      def initialize(num_threads:, queue:)
+        @num_threads = num_threads
+        @queue = queue
+        @threads = []
+      end
+
+      attr_reader :num_threads, :threads
+      private :threads
+
+      def spawn_threads
+        num_threads.times do
+          threads << Thread.new do
+            while running? || actions?
+              action_proc, action_payload = wait_for_action
+              action_proc.call(action_payload) if action_proc
+            end
+          end
+        end
+      end
+
+      def enqueue(action, payload)
+        queue.push([action, payload])
+      end
+
+      def stop
+        queue.close
+        threads.each(&:exit)
+        threads.clear
+        true
+      end
+
+      private
+
+      attr_reader :queue, :threads
+
+      def actions?
+        !queue.empty?
+      end
+
+      def running?
+        !queue.closed?
+      end
+
+      def dequeue_action
+        queue.pop(true)
+      end
+
+      def wait_for_action
+        queue.pop(false)
+      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.3'.freeze unless defined? VERSION
+end

data/lib/ji2p_jars.rb

@@ -0,0 +1,16 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+begin
+  require 'jar_dependencies'
+rescue LoadError
+  require 'net/i2p/router/0.9.43/router-0.9.43.jar'
+  require 'net/i2p/client/mstreaming/0.9.43/mstreaming-0.9.43.jar'
+  require 'net/i2p/client/streaming/0.9.43/streaming-0.9.43.jar'
+  require 'net/i2p/i2p/0.9.43/i2p-0.9.43.jar'
+end
+
+if defined? Jars
+  require_jar 'net.i2p', 'router', '0.9.43'
+  require_jar 'net.i2p.client', 'mstreaming', '0.9.43'
+  require_jar 'net.i2p.client', 'streaming', '0.9.43'
+  require_jar 'net.i2p', 'i2p', '0.9.43'
+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
+