dizby 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5942da7c03a278335c9ed7601035bada58a1fe0f
+  data.tar.gz: 4edfa688cb39af31316e8b55586274f910f00090
+SHA512:
+  metadata.gz: 63553d5c0ea0238b8337cdf87692f9da50792e14dc1df9cc079674275756097b2b3a968031491fae2589b20d5c70b6583a181b40267a3c22201cd17f8a769f3d
+  data.tar.gz: 684fbfdc941b8a823c81967fff3a711348edd9fbfbe3d4167e629ec0df07dd0bfc6952231b11fee0191ba70093d2e002b08b239930f63d731b08e4f6ca971792

data/.rubocop.yml

@@ -0,0 +1,10 @@
+---
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 12
+
+Style/SpecialGlobalVars:
+  Enabled: false

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2013-2015, Nathan Currier
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/dizby.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+require './lib/dizby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dizby'
+  spec.version       = Dizby::VERSION
+  spec.authors       = ['Nathan Currier']
+  spec.email         = ['nathan.currier@gmail.com']
+  spec.license       = 'BSD-3-Clause'
+
+  spec.description   = 'Distributed Ruby'
+  spec.summary       = 'Distributed Ruby'
+  spec.homepage      = 'https://gem.rideliner.net'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.add_runtime_dependency 'net-ssh', '~> 3.0'
+
+  spec.add_development_dependency 'rubocop', '~> 0.35'
+  spec.add_development_dependency 'reek', '~> 3.7'
+end

data/lib/dizby.rb

@@ -0,0 +1,12 @@
+
+require 'dizby/version'
+
+require 'dizby/service'
+
+require 'dizby/access/control_list'
+require 'dizby/tunnel/spawn_command'
+require 'dizby/converter/timed'
+
+require 'dizby/protocols/dead'
+require 'dizby/protocols/tcp'
+require 'dizby/protocols/secure'

data/lib/dizby/access/control_list.rb

@@ -0,0 +1,78 @@
+
+require 'dizby/access/entry'
+require 'dizby/access/list'
+
+module Dizby
+  module Access
+    class ControlList
+      # :deny_allow
+      # if allowed, allow
+      # else if denied, deny
+      # else, allow
+
+      # :allow_deny
+      # if denied, deny
+      # else if allowed, allow
+      # else, deny
+
+      def initialize(order = :deny_allow)
+        @order = order
+        @deny = List.new
+        @allow = List.new
+      end
+
+      def allow_socket?(soc)
+        allow_addr?(soc.peeraddr)
+      end
+
+      def allow_addr?(addr)
+        case @order
+        when :deny_allow
+          deny_allow?(addr)
+        when :allow_deny
+          allow_deny?(addr)
+        else
+          false
+        end
+      end
+
+      def install_list(list)
+        Hash[*list].each do |permission, domain|
+          domain = Entry.new(domain)
+          case permission.downcase
+          when 'allow'
+            @allow.push(domain)
+          when 'deny'
+            @deny.push(domain)
+          else
+            fail ArgumentError, "Invalid ACL entry #{list}"
+          end
+        end
+      end
+
+      private
+
+      def deny_allow?(addr)
+        return true if @allow.matches?(addr)
+        return false if @deny.matches?(addr)
+        true
+      end
+
+      def allow_deny?(addr)
+        return false if @deny.matches?(addr)
+        return true if @allow.matches?(addr)
+        false
+      end
+    end
+  end
+end
+
+# !! To allow unless explicitly denied
+# acl = Dizby::Access::ControlList.new(:allow_deny)
+# acl.install_list %w[ allow all ]
+# acl.install_list your_list_of_denies
+
+# !! To deny unless explicitly allowed
+# acl = Dizby::Access::ControlList.new(:deny_allow)
+# acl.install_list %w[ deny all ]
+# acl.install_list your_list_of_allows

data/lib/dizby/access/entry.rb

@@ -0,0 +1,61 @@
+
+require 'ipaddr'
+
+module Dizby
+  module Access
+    class Entry
+      def initialize(str)
+        if str == '*' || str == 'all'
+          @access = [:all]
+        elsif str.include?('*')
+          @access = [:name, pattern(str)]
+        else
+          begin
+            @access = [:ip, IPAddr.new(str)]
+          rescue ArgumentError
+            @access = [:name, pattern(str)]
+          end
+        end
+      end
+
+      def matches?(addr)
+        (scope, pattern) = @access
+
+        case scope
+        when :all
+          true
+        when :ip
+          matches_ip?(addr, pattern)
+        when :name
+          matches_name?(addr, pattern)
+        else
+          false
+        end
+      end
+
+      class << self
+        private
+
+        def pattern(str)
+          pattern = str.split('.')
+          pattern.map! { |segment| (segment == '*') ? '.+' : segment }
+          /^#{pattern.join('\\.')}$/
+        end
+
+        def matches_ip?(addr, pattern)
+          ipaddr = IPAddr.new(addr[3])
+          # map to ipv6 if entry is ipv6 and address is ipv4
+          ipaddr = ipaddr.ipv4_mapped if pattern.ipv6? && ipaddr.ipv4?
+
+          pattern.include?(ipaddr)
+        rescue ArgumentError
+          false
+        end
+
+        def matches_name?(addr, pattern)
+          pattern =~ addr[2]
+        end
+      end
+    end
+  end
+end

data/lib/dizby/access/insecure.rb

@@ -0,0 +1,30 @@
+
+require 'dizby/utility/string'
+
+module Dizby
+  INSECURE_METHODS = [:__send__]
+
+  def self.check_insecure_method(obj, msg_id)
+    unless msg_id.is_a?(Symbol)
+      fail ArgumentError, "#{Dizby.any_to_s(msg_id)} is not a symbol"
+    end
+
+    if INSECURE_METHODS.include?(msg_id)
+      fail SecurityError, "insecure method `#{msg_id}'"
+    end
+
+    check_hidden_method(obj, msg_id)
+  end
+
+  def self.check_hidden_method(obj, msg_id)
+    if obj.private_methods.include?(msg_id)
+      desc = Dizby.any_to_s(obj)
+      fail NoMethodError, "private method `#{msg_id}' called for #{desc}"
+    elsif obj.protected_methods.include?(msg_id)
+      desc = Dizby.any_to_s(obj)
+      fail NoMethodError, "protected method `#{msg_id}' called for #{desc}"
+    else
+      true
+    end
+  end
+end

data/lib/dizby/access/list.rb

@@ -0,0 +1,10 @@
+
+module Dizby
+  module Access
+    class List < Array
+      def matches?(addr)
+        any? { |entry| entry.matches?(addr) }
+      end
+    end
+  end
+end

data/lib/dizby/converter/simple.rb

@@ -0,0 +1,12 @@
+
+module Dizby
+  class IdConverter
+    def self.to_obj(ref)
+      ObjectSpace._id2ref(ref)
+    end
+
+    def self.to_id(obj)
+      obj.__id__
+    end
+  end
+end

data/lib/dizby/converter/timed.rb

@@ -0,0 +1,23 @@
+
+require 'dizby/utility/timed_collection'
+require 'dizby/converter/simple'
+
+module Dizby
+  class TimedIdConverter
+    # default timeout: 10 minutes, default step: 30 seconds
+    def initialize(timeout = 600_000, step = 30_000)
+      @collection = TimedCollection.new(timeout, step)
+    end
+
+    def to_obj(ref)
+      @collection.revive(ref)
+      IdConverter.to_obj(ref)
+    end
+
+    def to_id(obj)
+      key = IdConverter.to_id(obj)
+      @collection.add(key)
+      key
+    end
+  end
+end

data/lib/dizby/distributed/array.rb

@@ -0,0 +1,30 @@
+
+require 'dizby/distributed/object'
+require 'dizby/distributed/undumpable'
+
+module Dizby
+  class DistributedArray
+    def initialize(ary, server)
+      @ary = ary.map do |obj|
+        if obj.is_a? UndumpableObject
+          DistributedObject.new(obj, server)
+        else
+          begin
+            Marshal.dump(obj)
+            obj
+          rescue
+            DistributedObject.new(obj, server)
+          end
+        end
+      end
+    end
+
+    def self._load(str)
+      Marshal.load(str)
+    end
+
+    def _dump(_)
+      Marshal.dump(@ary)
+    end
+  end
+end

data/lib/dizby/distributed/object.rb

@@ -0,0 +1,44 @@
+
+require 'dizby/distributed/proxy'
+require 'dizby/access/insecure'
+
+module Dizby
+  class DistributedObject
+    def self._load(str)
+      SemiObjectProxy.new(*Marshal.load(str))
+    end
+
+    def _dump(_)
+      Marshal.dump [@server.uri, @server.to_id(@obj)]
+    end
+
+    def initialize(obj, server)
+      @obj = obj
+      @server = server
+    end
+
+    undef :to_s
+    undef :to_a if respond_to?(:to_a)
+
+    def respond_to?(msg_id, priv = false)
+      responds =
+        case msg_id
+        when :_dump
+          true
+        when :marshal_dump
+          false
+        else
+          method_missing(:respond_to?, msg_id, priv)
+        end
+
+      @server.log.debug("respond_to?(#{msg_id}) => #{responds}")
+      responds
+    end
+
+    def method_missing(msg_id, *args, &block)
+      @server.log.debug("calling: #{msg_id} #{args.join ', '}")
+      Dizby.check_insecure_method(@obj, msg_id)
+      @obj.__send__(msg_id, *args, &block)
+    end
+  end
+end

data/lib/dizby/distributed/proxy.rb

@@ -0,0 +1,41 @@
+
+require 'dizby/distributed/unknown'
+
+module Dizby
+  class ObjectProxy
+    def initialize(conn, ref = nil)
+      @ref = ref
+      @conn = conn
+    end
+
+    def method_missing(msg_id, *args, &block)
+      @conn.server.log.debug("calling through proxy: #{msg_id} #{args}")
+      @conn.send_request(@ref, msg_id, *args, &block)
+      succ, result = @conn.recv_reply
+
+      if succ
+        result
+      elsif result.is_a?(UnknownObject)
+        fail result
+      else
+        bt = Dizby.proxy_backtrace(@conn.remote_uri, result)
+        result.set_backtrace(bt + caller)
+        fail result
+      end
+    end
+
+    undef :to_s
+    undef :to_a if respond_to?(:to_a)
+
+    def respond_to?(msg_id, priv = false)
+      method_missing(:respond_to?, msg_id, priv)
+    end
+  end
+
+  def self.proxy_backtrace(prefix, exception)
+    bt = exception.backtrace.reject { |trace| /`__send__'$/ =~ trace }
+    bt.map { |trace| %r{\(drb://} =~ trace ? trace : "#{prefix}#{trace}" }
+    # TODO: why do we only add the prefix if the trace doesn't start with drb?
+    # What about the other schemes?
+  end
+end

data/lib/dizby/distributed/semi_proxy.rb

@@ -0,0 +1,26 @@
+
+require 'dizby/server/registration'
+require 'dizby/distributed/proxy'
+
+module Dizby
+  class SemiObjectProxy
+    def initialize(uri, ref)
+      @uri = uri
+      @ref = ref
+    end
+
+    def evaluate(server)
+      # cut down on network times by using the object if it exists locally
+      success, obj = Dizby.get_obj(@uri, @ref)
+
+      if success
+        server.log.debug("found local obj: #{obj.inspect}")
+        obj
+      else
+        server.log.debug("creating proxy to #{@ref} on #{@uri}")
+        client, = server.connect_to(@uri) # throw away the ref
+        ObjectProxy.new(client, @ref)
+      end
+    end
+  end
+end