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

data/lib/actor_system/core/props.rb

@@ -0,0 +1,45 @@
+require_relative 'observable_implementation.rb'
+
+module ActorSystem
+  module Core
+    class Prop
+      include ObservableImplementation
+
+      def initialize name, value
+        @name = name
+        @value = value
+      end
+
+      def value= value
+        @value = value
+        notify_observers(value)
+      end
+    end
+    class BasicObserverHash
+      def initialize values={}
+        @internal_hash = values
+      end
+
+      def [](key)
+        @internal_hash[key]
+      end
+
+      def []=(key, value)
+        if @internal_hash[key].nil?
+          p = Prop.new key,value
+          p.add_observer self
+          @internal_hash[key] = p
+        else
+          @internal_hash[key].value = value
+        end
+      end
+
+      def observer_update value
+        puts "Received update = #{value}"
+      end
+    end
+
+    class Props < BasicObserverHash
+    end
+  end
+end

data/lib/actor_system/dispatcher.rb

@@ -0,0 +1,12 @@
+module ActorSystem
+  module Dispatcher
+    class DispatcherImpl
+    end
+
+    class FiberDispatcher < DispatcherImpl
+    end
+
+    class ThreadDispatcher < DispatcherImpl
+    end
+  end
+end

data/lib/actor_system/mailbox.rb

@@ -0,0 +1,7 @@
+module ActorSystem
+  module Mailbox
+    class Impl
+      include ObservableImplementation
+    end
+  end
+end

data/lib/actor_system/message.rb

@@ -0,0 +1,60 @@
+module ActorSystem
+  module Message
+    def self.included cls
+      cls.class_exec do
+        extend Matcher
+
+        include MessageName
+      end
+    end
+
+    def self.extended receiver
+      receiver.instance_exec do
+        extend Matcher
+        extend MessageName
+      end
+    end
+
+    def self.=== object
+      if object.is_a? Symbol
+        true
+      else
+        super
+      end
+    end
+
+    module Matcher
+      def === other
+        other_message_name = Name.get other
+
+        message_name == other_message_name
+      end
+    end
+
+    module MessageName
+      def self.included cls
+        cls.class_exec do
+          extend ClassMethod
+
+          include InstanceMethod
+        end
+      end
+
+      def self.extended receiver
+        receiver.extend ClassMethod
+      end
+
+      module InstanceMethod
+        def message_name
+          self.class.message_name
+        end
+      end
+
+      module ClassMethod
+        def message_name
+          Name.get name
+        end
+      end
+    end
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,41 @@
+
+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

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,37 @@
+#require 'active_support'
+#require 'active_support/core_ext'
+#require 'active_support/dependencies'
+require 'logger'
+require 'java'
+$CLASSPATH << "file:///#{File.expand_path(File.join(__dir__, '..', 'config'))}/"
+
+require 'ji2p/environment.rb'
+
+module Ji2p
+  require_relative 'ji2p/version.rb'
+  autoload :Cluster, File.expand_path('ji2p/cluster.rb', __dir__)
+  autoload :Control, File.expand_path('ji2p/control.rb', __dir__)
+  autoload :Server,  File.expand_path('ji2p/server.rb', __dir__)
+  autoload :Startup, File.expand_path('ji2p/startup.rb', __dir__)
+  #ActiveSupport::Dependencies.autoload_paths << __dir__
+  #Dir.glob('**/').each do |dir|
+  #  ActiveSupport::Dependencies.autoload_paths << File.expand_path(dir, __dir__)
+  #end
+
+  # 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/cluster.rb

@@ -0,0 +1,6 @@
+module Ji2p
+  module Cluster
+    autoload :Etcd, File.expand_path('cluster/etcd.rb', __dir__)
+    autoload :Kubernetes, File.expand_path('cluster/kubernetes.rb', __dir__)
+  end
+end

data/lib/ji2p/cluster/etcd.rb

@@ -0,0 +1,5 @@
+module Ji2p::Cluster
+  module Etcd
+    autoload :Version3, File.expand_path('etcd/version3.rb', __dir__)
+  end
+end