dizby 1.3.0

data/lib/dizby/utility/monitor.rb

@@ -0,0 +1,9 @@
+
+require 'monitor'
+
+module Dizby
+  def self.monitor(obj)
+    obj.extend(MonitorMixin)
+    obj
+  end
+end

data/lib/dizby/utility/polymorphic_delegated.rb

@@ -0,0 +1,58 @@
+
+require 'dizby/utility/classic_access'
+require 'dizby/utility/delegator'
+
+module Dizby
+  module PolymorphicDelegated
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+
+      base.class_eval do
+        intercepted = [base, Object, Kernel, BasicObject, InstanceMethods]
+        intercepted = intercepted.map(&:instance_methods).inject(&:-)
+
+        @__delegated_methods__ =
+          intercepted.each_with_object({}) do |name, methods|
+            methods[name.to_sym] = base.instance_method(name)
+            base.send(:undef_method, name)
+          end
+      end
+    end
+
+    module ClassMethods
+      include ClassicAttributeAccess
+
+      def __delegated_methods__
+        instance_variable_get(:@__delegated_methods__)
+      end
+
+      def method_added(name)
+        return if [:method_missing, :initialize].include?(name)
+        @__delegated_methods__[name] = instance_method(name)
+        send(:undef_method, name)
+        nil
+      end
+    end
+
+    module InstanceMethods
+      def __delegate__(name, delegator, *args, &block)
+        method = self.class.__delegated_methods__[name]
+        method_args = [method.defined_in, method.executable, method.name]
+
+        # NOTE: This only works in Rubinius
+        Method.new(delegator, *method_args).call(*args, &block)
+      end
+
+      def method_missing(name, *args, &block)
+        args.unshift(self) if args.empty? || !args.first.is_a?(Delegator)
+
+        __delegate__ name, *args, &block
+      end
+
+      def respond_to?(sym, _priv = false)
+        super || self.class.__delegated_methods__.keys.include?(sym)
+      end
+    end
+  end
+end

data/lib/dizby/utility/self_pipe.rb

@@ -0,0 +1,12 @@
+
+module Dizby
+  SelfPipe = Struct.new(:read, :write) do
+    def close_read
+      read.close if read && !read.closed?
+    end
+
+    def close_write
+      write.close if write && !write.closed?
+    end
+  end
+end

data/lib/dizby/utility/semi_built.rb

@@ -0,0 +1,17 @@
+
+module Dizby
+  class SemibuiltObject
+    def initialize(klass, *args)
+      @klass = klass
+      @base_args = args
+    end
+
+    def with(*args, &block)
+      @klass.new(*@base_args, *args, &block)
+    end
+
+    def done
+      with
+    end
+  end
+end

data/lib/dizby/utility/string.rb

@@ -0,0 +1,8 @@
+
+module Dizby
+  def self.any_to_s(obj)
+    "#{obj}:#{obj.class}"
+  rescue
+    format '#<%s:0x%1x>', obj.class, obj.__id__
+  end
+end

data/lib/dizby/utility/timed_collection.rb

@@ -0,0 +1,39 @@
+
+require 'dizby/utility/monitor'
+require 'dizby/utility/timed_state'
+
+module Dizby
+  class InvalidIdentifier < RuntimeError; end
+
+  class TimedCollection
+    def initialize(timeout, step = timeout)
+      @timeout = timeout
+      @step = [timeout, step].min # don't allow a larger step than timeout
+      @states = Dizby.monitor({})
+      @updater = Thread.start { update }
+    end
+
+    def revive(id)
+      @states.synchronize { @states.fetch(id).revive }
+    rescue KeyError
+      raise InvalidIdentifier, 'identifier timed out or did not exist'
+    end
+
+    def add(id)
+      @states.synchronize { @states[id] = TimedState.new(@timeout) }
+    end
+
+    private
+
+    def update
+      loop do
+        sleep(@step)
+
+        @states.synchronize do
+          @states.each_value(&:update)
+          @states.keep_if { |_, state| state.alive? }
+        end
+      end
+    end
+  end
+end

data/lib/dizby/utility/timed_state.rb

@@ -0,0 +1,41 @@
+
+module Dizby
+  class TimedState
+    def initialize(timeout)
+      @timeout = timeout
+      revive
+    end
+
+    def update
+      previous = @last_update
+      @last_update = Time.now
+      timediff = (@last_update - previous) * 1000
+
+      @time += timediff
+      progress if @time >= @timeout
+    end
+
+    def alive?
+      @state != :dead
+    end
+
+    def revive
+      @state = :active
+      @time = 0
+      @last_update = Time.now
+    end
+
+    private
+
+    def progress
+      @time = 0
+      @state =
+        case @state
+        when :active
+          :inactive
+        when :inactive
+          :dead
+        end
+    end
+  end
+end

data/lib/dizby/version.rb

@@ -0,0 +1,4 @@
+
+module Dizby
+  VERSION = '1.3.0'
+end

data/lib/dizby/worker/connection.rb

@@ -0,0 +1,44 @@
+
+require 'dizby/worker/invoke_method'
+
+module Dizby
+  class ConnectionWorker
+    def initialize(server, conn)
+      @server = server
+      @conn = conn
+
+      @thread = Thread.start { process_requests }
+    end
+
+    def close
+      @conn.close unless @conn.closed?
+
+      # TODO: @thread gets set to nil for some reason...
+      @thread.join if @thread
+    end
+
+    private
+
+    def process_requests
+      loop { break unless process_request }
+    rescue RemoteServerShutdown
+      @server.log.debug("lost connection to server at #{@conn.remote_uri}")
+    ensure
+      @conn.close unless @conn.closed?
+    end
+
+    def process_request
+      succ, result = InvokeMethod.new(@server, *@conn.recv_request).perform
+
+      @server.log.backtrace(result) unless succ
+
+      begin
+        @conn.send_reply(succ, result)
+      rescue
+        @server.log.backtrace($!)
+      end
+
+      succ
+    end
+  end
+end

data/lib/dizby/worker/invoke_method.rb

@@ -0,0 +1,55 @@
+
+require 'dizby/distributed/array'
+
+module Dizby
+  class InvokeMethod
+    def initialize(server, obj, msg, argv, block)
+      @obj = obj
+      @msg_id = msg.intern
+      @argv = argv
+      @block = block && proc { |*args| call_block(block, *args) }
+
+      @server = server
+    end
+
+    def perform
+      result = send_to_object
+
+      # TODO: do we care what the @msg_id is?
+      # Should we convert to a DistributedArray regardless?
+      if @msg_id == :to_ary && result.class == Array
+        result = DistributedArray.new(result, @server)
+      end
+
+      [true, result]
+    rescue StandardError, ScriptError, Interrupt
+      @server.log.backtrace($!)
+      [false, $!]
+    end
+
+    private
+
+    def call_block(block, *args)
+      if args.size == 1 && args[0].is_a?(Array)
+        args[0] = DistributedArray.new(args[0], @server)
+      end
+
+      block.call(*args)
+    rescue LocalJumpError
+      handle_jump_error($!)
+    end
+
+    def handle_jump_error(err)
+      case err.reason
+      when :break
+        err.exit_value
+      else
+        fail err
+      end
+    end
+
+    def send_to_object
+      @obj.__send__(@msg_id, *@argv, &@block)
+    end
+  end
+end

data/lib/dizby/worker/server.rb

@@ -0,0 +1,39 @@
+
+require 'dizby/worker/connection'
+
+module Dizby
+  class ServiceWorker
+    def initialize(server)
+      @server = server
+      @thread = Thread.start { run }
+    end
+
+    def join
+      @thread.join if @thread
+    end
+
+    private
+
+    def run
+      connections = []
+      loop do
+        conn = accept_connection
+        connections << conn if conn
+      end
+    rescue LocalServerShutdown
+      @server.log.debug('Server shutdown')
+    ensure
+      @server.close if @server.alive?
+
+      connections.each(&:close)
+    end
+
+    def accept_connection
+      connection = @server.accept
+      return nil unless connection
+
+      @server.add_uri_alias connection.remote_uri
+      ConnectionWorker.new(@server, connection)
+    end
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: dizby
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Nathan Currier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  name: net-ssh
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  type: :development
+  name: rubocop
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+- !ruby/object:Gem::Dependency
+  type: :development
+  name: reek
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: Distributed Ruby
+email:
+- nathan.currier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- LICENSE
+- dizby.gemspec
+- lib/dizby.rb
+- lib/dizby/access/control_list.rb
+- lib/dizby/access/entry.rb
+- lib/dizby/access/insecure.rb
+- lib/dizby/access/list.rb
+- lib/dizby/converter/simple.rb
+- lib/dizby/converter/timed.rb
+- lib/dizby/distributed/array.rb
+- lib/dizby/distributed/object.rb
+- lib/dizby/distributed/proxy.rb
+- lib/dizby/distributed/semi_proxy.rb
+- lib/dizby/distributed/undumpable.rb
+- lib/dizby/distributed/unknown.rb
+- lib/dizby/error.rb
+- lib/dizby/protocol/basic.rb
+- lib/dizby/protocol/manager.rb
+- lib/dizby/protocol/refined.rb
+- lib/dizby/protocols/dead.rb
+- lib/dizby/protocols/secure.rb
+- lib/dizby/protocols/tcp.rb
+- lib/dizby/protocols/unix.rb
+- lib/dizby/server/abstract.rb
+- lib/dizby/server/basic.rb
+- lib/dizby/server/registration.rb
+- lib/dizby/service.rb
+- lib/dizby/stream/client.rb
+- lib/dizby/stream/connection.rb
+- lib/dizby/stream/messenger.rb
+- lib/dizby/stream/query_ref.rb
+- lib/dizby/stream/readable.rb
+- lib/dizby/stream/writable.rb
+- lib/dizby/tunnel/abstract.rb
+- lib/dizby/tunnel/basic.rb
+- lib/dizby/tunnel/basic_spawn.rb
+- lib/dizby/tunnel/bidirectional_strategy.rb
+- lib/dizby/tunnel/factory.rb
+- lib/dizby/tunnel/local_strategy.rb
+- lib/dizby/tunnel/spawn_command.rb
+- lib/dizby/tunnel/spawned.rb
+- lib/dizby/tunnel/tunnelable_local.rb
+- lib/dizby/tunnel/tunnelable_remote.rb
+- lib/dizby/utility/classic_access.rb
+- lib/dizby/utility/configurable.rb
+- lib/dizby/utility/delegator.rb
+- lib/dizby/utility/io_barrier.rb
+- lib/dizby/utility/log.rb
+- lib/dizby/utility/monitor.rb
+- lib/dizby/utility/polymorphic_delegated.rb
+- lib/dizby/utility/self_pipe.rb
+- lib/dizby/utility/semi_built.rb
+- lib/dizby/utility/string.rb
+- lib/dizby/utility/timed_collection.rb
+- lib/dizby/utility/timed_state.rb
+- lib/dizby/version.rb
+- lib/dizby/worker/connection.rb
+- lib/dizby/worker/invoke_method.rb
+- lib/dizby/worker/server.rb
+homepage: https://gem.rideliner.net
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Distributed Ruby
+test_files: []