javonet-nodejs-sdk 2.4.4 → 2.4.6

package/Binaries/Ruby/MacOs/X64/external_lib/singleton.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: false
+
+# The Singleton module implements the Singleton pattern.
+#
+# == Usage
+#
+# To use Singleton, include the module in your class.
+#
+#    class Klass
+#       include Singleton
+#       # ...
+#    end
+#
+# This ensures that only one instance of Klass can be created.
+#
+#      a,b = Klass.instance, Klass.instance
+#
+#      a == b
+#      # => true
+#
+#      Klass.new
+#      # => NoMethodError - new is private ...
+#
+# The instance is created at upon the first call of Klass.instance().
+#
+#      class OtherKlass
+#        include Singleton
+#        # ...
+#      end
+#
+#      ObjectSpace.each_object(OtherKlass){}
+#      # => 0
+#
+#      OtherKlass.instance
+#      ObjectSpace.each_object(OtherKlass){}
+#      # => 1
+#
+#
+# This behavior is preserved under inheritance and cloning.
+#
+# == Implementation
+#
+# This above is achieved by:
+#
+# *  Making Klass.new and Klass.allocate private.
+#
+# *  Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
+#    Singleton properties are kept when inherited and cloned.
+#
+# *  Providing the Klass.instance() method that returns the same object each
+#    time it is called.
+#
+# *  Overriding Klass._load(str) to call Klass.instance().
+#
+# *  Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
+#    cloning or duping.
+#
+# == Singleton and Marshal
+#
+# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
+# default will strip state information, e.g. instance variables from the instance.
+# Classes using Singleton can provide custom _load(str) and _dump(depth) methods
+# to retain some of the previous state of the instance.
+#
+#    require 'singleton'
+#
+#    class Example
+#      include Singleton
+#      attr_accessor :keep, :strip
+#      def _dump(depth)
+#        # this strips the @strip information from the instance
+#        Marshal.dump(@keep, depth)
+#      end
+#
+#      def self._load(str)
+#        instance.keep = Marshal.load(str)
+#        instance
+#      end
+#    end
+#
+#    a = Example.instance
+#    a.keep = "keep this"
+#    a.strip = "get rid of this"
+#
+#    stored_state = Marshal.dump(a)
+#
+#    a.keep = nil
+#    a.strip = nil
+#    b = Marshal.load(stored_state)
+#    p a == b  #  => true
+#    p a.keep  #  => "keep this"
+#    p a.strip #  => nil
+#
+module Singleton
+  VERSION = "0.2.0"
+
+  # Raises a TypeError to prevent cloning.
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+
+  # Raises a TypeError to prevent duping.
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  # By default, do not retain any state when marshalling.
+  def _dump(depth = -1)
+    ''
+  end
+
+  module SingletonClassMethods # :nodoc:
+
+    def clone # :nodoc:
+      Singleton.__init__(super)
+    end
+
+    # By default calls instance(). Override to retain singleton state.
+    def _load(str)
+      instance
+    end
+
+    def instance # :nodoc:
+      @singleton__instance__ || @singleton__mutex__.synchronize { @singleton__instance__ ||= new }
+    end
+
+    private
+
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+  end
+
+  class << Singleton # :nodoc:
+    def __init__(klass) # :nodoc:
+      klass.instance_eval {
+        @singleton__instance__ = nil
+        @singleton__mutex__ = Thread::Mutex.new
+      }
+      klass
+    end
+
+    private
+
+    # extending an object with Singleton is a bad idea
+    undef_method :extend_object
+
+    def append_features(mod)
+      #  help out people counting on transitive mixins
+      unless mod.instance_of?(Class)
+        raise TypeError, "Inclusion of the OO-Singleton module in module #{mod}"
+      end
+      super
+    end
+
+    def included(klass)
+      super
+      klass.private_class_method :new, :allocate
+      klass.extend SingletonClassMethods
+      Singleton.__init__(klass)
+    end
+  end
+
+  ##
+  # :singleton-method: _load
+  #  By default calls instance(). Override to retain singleton state.
+
+  ##
+  # :singleton-method: instance
+  #  Returns the singleton instance.
+end

package/Binaries/Ruby/MacOs/X64/utils/command_type.rb

@@ -33,6 +33,8 @@ class CommandType
   AS_REF = 31
   AS_OUT = 32
   GET_REF_VALUE = 33
+  ENABLE_NAMESPACE = 34
+  ENABLE_TYPE = 35
 
   def self.get_name(command_number)
     case command_number
@@ -99,11 +101,17 @@ class CommandType
     when 30
       return 'GET_ENUM_VALUE'
     when 31
-	  return 'AS_REF'
+      return 'AS_REF'
     when 32
-	  return 'AS_OUT'
+      return 'AS_OUT'
     when 33
-	  return 'GET_REF_VALUE'
+      return 'GET_REF_VALUE'
+    when 34
+      return 'ENABLE_NAMESPACE'
+    when 35
+      return 'ENABLE_TYPE'
+    else
+      raise 'Unknown command type'
     end
   end
 end

package/Binaries/Ruby/Windows/X64/core/handler/{command_handler/abstract_command_handler.rb → abstract_command_handler.rb}

@@ -1,4 +1,4 @@
-require_relative '../handler_dictionary'
+require_relative 'handler_dictionary'
 
 class AbstractCommandHandler
 

package/Binaries/Ruby/Windows/X64/core/handler/{command_handler/destruct_reference_handler.rb → destruct_reference_handler.rb}

@@ -1,5 +1,5 @@
 require_relative 'abstract_command_handler'
-require_relative '../../../core/handler/references_cache'
+require_relative '../reference_cache/references_cache'
 
 class DestructReferenceHandler < AbstractCommandHandler
   def initialize

package/Binaries/Ruby/Windows/X64/core/handler/enable_namespace_handler.rb

@@ -0,0 +1,31 @@
+require_relative 'abstract_command_handler'
+require_relative '../namespace_cache/namespace_cache'
+
+class EnableNamespaceHandler < AbstractCommandHandler
+  def initialize
+    @required_parameters_count = 1
+  end
+
+  def process(command)
+    begin
+      if command.payload.length < @required_parameters_count
+        raise ArgumentError.new "#{self.class.name} parameters mismatch"
+      end
+      namespace_cache = NamespaceCache.instance
+
+      command.payload.each do |payload|
+        if payload.is_a? String
+          namespace_cache.cache_namespace(payload)
+        elsif payload.is_a? Array
+          payload.each do |type_to_enable|
+            namespace_cache.cache_namespace(type_to_enable)
+            cache_namespace
+          end
+        end
+      end
+      0
+    rescue Exception => e
+      return e
+    end
+  end
+end

package/Binaries/Ruby/Windows/X64/core/handler/enable_type_handler.rb

@@ -0,0 +1,32 @@
+require_relative 'abstract_command_handler'
+require_relative '../type_cache/type_cache'
+
+class EnableTypeHandler < AbstractCommandHandler
+  def initialize
+    @required_parameters_count = 1
+  end
+
+  def process(command)
+    begin
+      if command.payload.length < @required_parameters_count
+        raise "#{self.class.name} parameters mismatch!"
+      end
+
+      type_cache = TypeCache.instance
+
+      command.payload.each do |payload|
+        if payload.is_a? String
+          type_cache.cache_type(payload)
+        elsif payload.is_a? Array
+          payload.each do |type_to_enable|
+            type_cache.cache_type(type_to_enable)
+          end
+        end
+
+      end
+      0
+    end
+  rescue Exception => e
+    return e
+  end
+end

package/Binaries/Ruby/Windows/X64/core/handler/{command_handler/get_instance_field_handler.rb → get_instance_field_handler.rb}

@@ -6,7 +6,7 @@ class GetInstanceFieldHandler < AbstractCommandHandler
   end
 
   def process(command)
-    return get_instance_field(command)
+    get_instance_field(command)
   end
 
   def get_instance_field(command)

package/Binaries/Ruby/Windows/X64/core/handler/{command_handler/get_static_field_handler.rb → get_static_field_handler.rb}

@@ -6,7 +6,7 @@ class GetStaticFieldHandler < AbstractCommandHandler
   end
 
   def process(command)
-    return get_static_field(command)
+    get_static_field(command)
   end
 
   def get_static_field(command)

package/Binaries/Ruby/Windows/X64/core/handler/get_type_handler.rb

@@ -0,0 +1,59 @@
+require_relative 'abstract_command_handler'
+require_relative '../namespace_cache/namespace_cache'
+require_relative '../type_cache/type_cache'
+
+class GetTypeHandler < AbstractCommandHandler
+  def initialize
+    @required_parameters_count = 1
+    @namespace_cache = NamespaceCache.instance
+    @type_cache = TypeCache.instance
+  end
+
+  def process(command)
+    begin
+      if command.payload.length < @required_parameters_count
+        raise "#{self.class.name} parameters mismatch!"
+      end
+
+      type_to_return = _get_type_from_payload(command)
+
+      if type_to_return.nil?
+        raise "Type #{command.payload[0]} not found"
+      end
+
+      if (@namespace_cache.is_namespace_cache_empty? && @type_cache.is_type_cache_empty?) || # both caches are empty
+        @namespace_cache.is_type_allowed(type_to_return) || # namespace is allowed
+        @type_cache.is_type_allowed(type_to_return)
+        # continue - type is allowed
+      else
+        allowed_namespaces = @namespace_cache.get_cached_namespaces.join(", ")
+        allowed_types = @type_cache.get_cached_types.join(", ")
+        raise "Type #{type_to_return.name} not allowed. \nAllowed namespaces: #{allowed_namespaces}\nAllowed types: #{allowed_types}"
+      end
+
+      type_to_return
+    rescue Exception => e
+      return e
+    end
+end
+
+    private
+
+    def _get_type_from_payload(command)
+      if command.payload.length == 1
+        type_name = command.payload[0].split("::")
+        if type_name.length == 1
+          return Object::const_get(type_name[0])
+        else
+          return _get_type_from_nested_payload(type_name)
+        end
+      else
+        return _get_type_from_nested_payload(command.payload)
+      end
+    end
+
+    def _get_type_from_nested_payload(payload)
+      loaded_module = Object::const_get(payload[0..-2].join("::"))
+      loaded_module.const_get(payload[-1])
+    end
+  end

package/Binaries/Ruby/Windows/X64/core/handler/handler.rb

@@ -1,26 +1,28 @@
 require_relative '../../utils/runtime_name'
 require_relative '../../utils/command_type'
-require_relative '../../core/handler/abstract_handler'
-require_relative '../../core/handler/command_handler/value_handler'
-require_relative '../../core/handler/command_handler/load_library_handler'
-require_relative '../../core/handler/command_handler/invoke_static_method_handler'
-require_relative '../../core/handler/command_handler/get_static_field_handler'
-require_relative '../../core/handler/command_handler/get_instance_field_handler'
-require_relative '../../core/handler/command_handler/set_instance_field_handler'
-require_relative '../../core/handler/command_handler/create_class_instance_handler'
-require_relative '../../core/handler/command_handler/set_static_field_handler'
-require_relative '../../core/handler/command_handler/get_type_handler'
-require_relative '../../core/handler/command_handler/invoke_instance_method_handler'
-require_relative '../../core/handler/command_handler/resolve_instance_handler'
-require_relative '../../core/handler/command_handler/casting_handler'
-require_relative '../../core/handler/command_handler/destruct_reference_handler'
-require_relative '../../core/handler/command_handler/array_get_item_handler'
-require_relative '../../core/handler/command_handler/array_get_size_handler'
-require_relative '../../core/handler/command_handler/array_get_rank_handler'
-require_relative '../../core/handler/command_handler/array_set_item_handler'
-require_relative '../../core/handler/command_handler/array_handler'
-require_relative '../../core/handler/references_cache'
 require_relative '../../core/handler/handler_dictionary'
+require_relative '../../core/handler/abstract_handler'
+require_relative '../../core/handler/value_handler'
+require_relative '../../core/handler/load_library_handler'
+require_relative '../../core/handler/invoke_static_method_handler'
+require_relative '../../core/handler/get_static_field_handler'
+require_relative '../../core/handler/get_instance_field_handler'
+require_relative '../../core/handler/set_instance_field_handler'
+require_relative '../../core/handler/create_class_instance_handler'
+require_relative '../../core/handler/set_static_field_handler'
+require_relative '../../core/handler/get_type_handler'
+require_relative '../../core/handler/invoke_instance_method_handler'
+require_relative '../../core/handler/resolve_instance_handler'
+require_relative '../../core/handler/casting_handler'
+require_relative '../../core/handler/destruct_reference_handler'
+require_relative '../../core/handler/array_get_item_handler'
+require_relative '../../core/handler/array_get_size_handler'
+require_relative '../../core/handler/array_get_rank_handler'
+require_relative '../../core/handler/array_set_item_handler'
+require_relative '../../core/handler/array_handler'
+require_relative '../../core/handler/enable_namespace_handler'
+require_relative '../../core/handler/enable_type_handler'
+require_relative '../../core/reference_cache/references_cache'
 require_relative '../../core/exceptions/exception_serializer'
 
 
@@ -46,6 +48,8 @@ class Handler < AbstractHandler
     array_get_rank_handler = ArrayGetRankHandler.new
     array_set_item_handler = ArraySetItemHandler.new
     array_handler = ArrayHandler.new
+    enable_namespace_handler = EnableNamespaceHandler.new
+    enable_type_handler = EnableTypeHandler.new
 
 
     $handler_dict[CommandType::VALUE] = value_handler
@@ -66,6 +70,8 @@ class Handler < AbstractHandler
     $handler_dict[CommandType::ARRAY_GET_RANK] = array_get_rank_handler
     $handler_dict[CommandType::ARRAY_SET_ITEM] = array_set_item_handler
     $handler_dict[CommandType::ARRAY] = array_handler
+    $handler_dict[CommandType::ENABLE_NAMESPACE] = enable_namespace_handler
+    $handler_dict[CommandType::ENABLE_TYPE] = enable_type_handler
   end
 
 
@@ -76,22 +82,22 @@ class Handler < AbstractHandler
     end
     response = $handler_dict[command.command_type].handle_command(command)
       if is_response_simple_type(response)
-        return Command.create_response(response, command.runtime_name)
+        Command.create_response(response, command.runtime_name)
       elsif response.is_a? Exception
         return ExceptionSerializer.serialize_exception(response, command)
       else
         reference_cache = ReferencesCache.instance
         guid = reference_cache.cache_reference(response)
-        return Command.create_reference(guid, command.runtime_name)
+        Command.create_reference(guid, command.runtime_name)
       end
   end
 
   def is_response_simple_type(response)
-    return (response.is_a? String or response.is_a? Float or response.is_a? Integer or response.is_a? TrueClass or response.is_a? FalseClass)
+    (response.is_a? String or response.is_a? Float or response.is_a? Integer or response.is_a? TrueClass or response.is_a? FalseClass)
   end
 
   def is_response_array(response)
-    return response.is_a? Array
+    response.is_a? Array
   end
 
 

package/Binaries/Ruby/Windows/X64/core/handler/{command_handler/resolve_instance_handler.rb → resolve_instance_handler.rb}

@@ -1,4 +1,4 @@
-require_relative '../references_cache'
+require_relative '../reference_cache/references_cache'
 require_relative 'abstract_command_handler'
 
 class ResolveInstanceHandler < AbstractCommandHandler

package/Binaries/Ruby/Windows/X64/core/namespace_cache/namespace_cache.rb

@@ -0,0 +1,40 @@
+require_relative './../../external_lib/singleton'
+
+class NamespaceCache
+  include Singleton
+
+  attr_accessor :namespace_cache
+
+  def initialize
+    @namespace_cache = []
+  end
+
+  def cache_namespace(namespace_regex)
+    @namespace_cache << namespace_regex
+  end
+
+  def is_namespace_cache_empty?
+    @namespace_cache.empty?
+  end
+
+  def is_type_allowed(type_to_check)
+    if type_to_check.is_a?(Module)
+      name_to_check = type_to_check.name
+    else
+      name_to_check = "#{type_to_check.class.name}"
+    end
+
+    @namespace_cache.any? do |pattern|
+      /#{pattern}/.match?(name_to_check)
+    end
+  end
+
+def get_cached_namespaces
+  @namespace_cache
+end
+
+def clear_cache
+  @namespace_cache.clear
+  0
+end
+end

package/Binaries/Ruby/Windows/X64/core/reference_cache/references_cache.rb

@@ -0,0 +1,33 @@
+require_relative './../../external_lib/singleton'
+require_relative './../../external_lib/securerandom'
+
+class ReferencesCache
+  include Singleton
+
+  def initialize
+    @references_cache = Hash.new
+  end
+
+  def cache_reference(object_reference)
+    uuid_ = SecureRandom.uuid
+    @references_cache[uuid_] = object_reference
+    uuid_
+  end
+
+  def resolve_reference(guid)
+    if @references_cache[guid].nil?
+      raise 'Unable to resolve reference with id: ' + guid.to_s
+    else
+      @references_cache[guid]
+    end
+  end
+
+  def delete_reference(guid)
+    if @references_cache[guid].nil?
+      raise 'Object not found in reference cache'
+    else
+      @references_cache.delete(guid)
+      0
+    end
+  end
+end

package/Binaries/Ruby/Windows/X64/core/type_cache/type_cache.rb

@@ -0,0 +1,40 @@
+require_relative './../../external_lib/singleton'
+
+class TypeCache
+  include Singleton
+
+  attr_accessor :type_cache
+
+  def initialize
+    @type_cache = []
+  end
+
+  def cache_type(type_regex)
+    @type_cache << type_regex
+  end
+
+  def is_type_cache_empty?
+    @type_cache.empty?
+  end
+
+  def is_type_allowed(type_to_check)
+    if type_to_check.is_a?(Module)
+      name_to_check = type_to_check.name
+    else
+      name_to_check = "#{type_to_check.class.name}::#{type_to_check.name}"
+    end
+
+    @type_cache.any? do
+|pattern| /#{pattern}/.match?(name_to_check)
+    end
+  end
+
+  def get_cached_types
+    @type_cache
+  end
+
+  def clear_cache
+    @type_cache.clear
+    0
+  end
+end