dizby 1.3.0

data/lib/dizby/distributed/undumpable.rb

@@ -0,0 +1,8 @@
+
+module Dizby
+  module UndumpableObject
+    def _dump(_)
+      fail TypeError, 'can\'t dump'
+    end
+  end
+end

data/lib/dizby/distributed/unknown.rb

@@ -0,0 +1,57 @@
+
+require 'dizby/error'
+
+module Dizby
+  class UnknownObject
+    def initialize(err, buf)
+      case err.to_s
+      when /uninitialized constant (\S+)/
+        @name = $~[1]
+      when %r{undefined class/module (\S+)}
+        @name = $~[1]
+      else
+        @name = nil
+      end
+
+      @buf = buf
+    end
+
+    attr_reader :name, :buf
+
+    def self._load(str)
+      Marshal.load(str)
+    rescue NameError, ArgumentError
+      UnknownObject.new($!, str)
+    end
+
+    def _dump(_)
+      Marshal.dump(@buf)
+    end
+
+    def reload
+      self.class._load @buf
+    end
+
+    def exception
+      UnknownObjectError.new self
+    end
+  end
+
+  class UnknownObjectError < DistributedError
+    def initialize(unknown)
+      @unknown = unknown
+      super unknown.name
+    end
+
+    # give access to the UnknownObject class
+    attr_reader :unknown
+
+    def self._load(str)
+      Marshal.load(str)
+    end
+
+    def _dump(_)
+      Marshal.dump(@unknown)
+    end
+  end
+end

data/lib/dizby/error.rb

@@ -0,0 +1,29 @@
+
+module Dizby
+  class DistributedError < RuntimeError; end
+  class ConnectionError < DistributedError; end
+  class ServerNotFound < DistributedError; end
+  class BadURI < DistributedError; end
+  class BadScheme < DistributedError; end
+  class LocalServerShutdown < DistributedError; end
+  class RemoteServerShutdown < ConnectionError; end
+  class SpawnError < DistributedError; end
+
+  class NonAcceptingServer < DistributedError
+    def initialize(server)
+      @server = server
+    end
+
+    attr_reader :server
+  end
+
+  class RemoteDistributedError < DistributedError
+    def initialize(error)
+      @reason = error.class.to_s
+      super("#{error.message} (#{@reason})")
+      set_backtrace(error.backtrace)
+    end
+
+    attr_reader :reason
+  end
+end

data/lib/dizby/protocol/basic.rb

@@ -0,0 +1,31 @@
+
+require 'dizby/protocol/manager'
+require 'dizby/protocol/refined'
+
+module Dizby
+  module BasicProtocol
+    module ClassMethods
+      attr_reader :scheme
+
+      def get_refinement(type)
+        instance_variable_get(:"@#{type}_refined")
+      rescue NameError
+        nil
+      end
+
+      protected
+
+      attr_writer :scheme
+
+      def refine(type, regex, &block)
+        refined = RefinedProtocol.new(regex, &block)
+        instance_variable_set(:"@#{type}_refined", refined)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      ProtocolManager.add_protocol(base)
+    end
+  end
+end

data/lib/dizby/protocol/manager.rb

@@ -0,0 +1,62 @@
+
+require 'dizby/error'
+
+module Dizby
+  class ProtocolManager
+    # TODO: all required portions of a Protocol class need to be documented
+    class << self
+      def add_protocol(klass)
+        @protocols << klass
+      end
+
+      def open_client(server, uri)
+        call_refined(uri, :client, server)
+      end
+
+      def open_server(uri, front, config)
+        call_refined(uri, :server, front, config)
+      end
+
+      def spawn_server(server, command, uri)
+        call_refined(uri, :spawn, server, command)
+      end
+
+      private
+
+      def call_refined(uri, refiner, *base_args)
+        klass = get_protocol(uri)
+        refined = refine_protocol(klass, refiner)
+        args = get_arguments(refined, uri)
+        refined.call(*base_args, args)
+      end
+
+      def get_protocol(uri)
+        scheme = '' if uri.empty?
+        scheme ||= uri.split(':').first
+        fail BadScheme, "can't retrieve scheme: #{uri}" unless scheme
+
+        protocol = @protocols.find { |klass| klass.scheme == scheme }
+        protocol || fail(BadScheme, "scheme not found: #{scheme}")
+      end
+
+      def refine_protocol(protocol, refinement)
+        refined = protocol.get_refinement(refinement)
+
+        unless refined
+          fail NotImplementedError,
+               "#{refinement} refinement not supported for #{protocol}"
+        end
+
+        refined
+      end
+
+      def get_arguments(refined, uri)
+        fail BadURI, "can't parse uri: #{uri}" unless refined.regex =~ uri
+
+        $~[1..-1]
+      end
+    end
+
+    @protocols = []
+  end
+end

data/lib/dizby/protocol/refined.rb

@@ -0,0 +1,23 @@
+
+module Dizby
+  PROTOCOL_REGEX = {
+    user: '(?:(.+?)@)',
+    host: '(.*?)',
+    port: '(?::(\d+))',
+    file: '(.+?)',
+    query: '(?:\?(.*?))'
+  }
+
+  class RefinedProtocol
+    def initialize(regex, &block)
+      @regex = /^#{format(regex, Dizby::PROTOCOL_REGEX)}$/
+      @block = block
+    end
+
+    attr_reader :regex
+
+    def call(*args)
+      @block.call(*args)
+    end
+  end
+end

data/lib/dizby/protocols/dead.rb

@@ -0,0 +1,24 @@
+
+require 'dizby/protocol/basic'
+require 'dizby/server/abstract'
+
+module Dizby
+  class DeadProtocol
+    include BasicProtocol
+
+    self.scheme = ''
+
+    refine(:server, '') do |_, config|
+      fail NonAcceptingServer, Server.new(config)
+    end
+
+    class Server < AbstractServer
+      # A DeadProtocol server doesn't allow backwards connections
+      # therefore, making a distributed object goes against that.
+      def make_distributed(*_)
+        fail DistributedError,
+             'distributed objects not supported from DeadProtocol'
+      end
+    end
+  end
+end

data/lib/dizby/protocols/secure.rb

@@ -0,0 +1,87 @@
+
+require 'dizby/protocol/basic'
+require 'dizby/stream/client'
+require 'dizby/stream/connection'
+require 'dizby/server/basic'
+require 'dizby/tunnel/basic'
+require 'dizby/tunnel/factory'
+
+require 'socket'
+
+module Dizby
+  class SecureProtocol
+    include BasicProtocol
+
+    self.scheme = 'drbsec'
+
+    refine(:spawn,
+           "#{scheme}://%{user}?%{host}%{port}?%{query}?"
+          ) do |server, command, (user, host, port, query)|
+      factory = TunnelFactory.new(server, port)
+      tunnel = factory.create(BasicSpawnTunnel).with(command, user, host)
+
+      socket = TCPSocket.open('localhost', tunnel.local_port)
+      TCProtocol.apply_sockopt(socket)
+
+      delegate = delegatable_tunnel(factory, server, tunnel)
+      client = BasicClient.new(delegate, socket,
+                               "#{scheme}://#{host}:#{tunnel.remote_port}")
+      query &&= QueryRef.new(query)
+
+      [client, query]
+    end
+
+    refine(:client,
+           "#{scheme}://%{user}?%{host}%{port}%{query}?"
+          ) do |server, (user, host, port, query)|
+      port &&= port.to_i
+
+      factory = TunnelFactory.new(server, port)
+      tunnel = factory.create(BasicTunnel).with(user, host)
+
+      socket = TCPSocket.open('localhost', tunnel.local_port)
+      TCProtocol.apply_sockopt(socket)
+
+      delegate = delegatable_tunnel(factory, server, tunnel)
+      client = BasicClient.new(delegate, socket, "#{scheme}://#{host}:#{port}")
+      query &&= QueryRef.new(query)
+
+      [client, query]
+    end
+
+    def self.delegatable_tunnel(factory, server, tunnel)
+      if factory.bidirectional?
+        ResponseTunnel.new(server, tunnel)
+      else
+        DirectTunnel.new(server, tunnel)
+      end
+    end
+
+    class DirectTunnel < Delegator
+      def initialize(server, tunnel)
+        super(server)
+
+        @tunnel = tunnel
+      end
+
+      def close
+        @tunnel.close
+        super
+        @tunnel.thread.join
+      end
+    end
+
+    class ResponseTunnel < DirectTunnel
+      def initialize(server, tunnel)
+        super(server, tunnel)
+
+        @remote_port = tunnel.remote_port
+      end
+
+      def uri # overload the uri of the server
+        # we use the drb protocol for the rebound connection
+        "drb://localhost:#{@remote_port}"
+      end
+    end
+  end
+end

data/lib/dizby/protocols/tcp.rb

@@ -0,0 +1,98 @@
+
+require 'dizby/protocol/basic'
+require 'dizby/stream/client'
+require 'dizby/stream/connection'
+require 'dizby/server/basic'
+
+require 'socket'
+
+module Dizby
+  class TCProtocol
+    include BasicProtocol
+
+    self.scheme = 'drb'
+
+    refine(:server,
+           "#{scheme}://%{host}?%{port}?"
+          ) do |front, config, (host, port)|
+      port &&= port.to_i
+
+      Server.new front, config, host, port
+    end
+
+    refine(:client,
+           "#{scheme}://%{host}?%{port}?%{query}?"
+          ) do |server, (host, port, query)|
+      port &&= port.to_i
+
+      socket = TCPSocket.open(host, port)
+      apply_sockopt(socket)
+
+      client = BasicClient.new(server, socket, "#{scheme}://#{host}:#{port}")
+      query &&= QueryRef.new(query)
+
+      [client, query]
+    end
+
+    class << self
+      def getservername
+        Socket.gethostbyname(Socket.gethostname)[0]
+      rescue
+        'localhost'
+      end
+
+      def apply_sockopt(soc)
+        soc.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      end
+    end
+
+    class Server < BasicServer
+      include PolymorphicDelegated
+
+      def initialize(front, config, host, port)
+        port ||= 0
+
+        if host.empty?
+          host = TCProtocol.getservername
+          socket = self.class.open_socket_inaddr_any(host, port)
+        else
+          socket = TCPServer.open(host, port)
+        end
+
+        port = socket.addr[1] if port == 0
+
+        super("drb://#{host}:#{port}", front, socket, config)
+
+        TCProtocol.apply_sockopt(socket)
+
+        @port = port
+      end
+
+      attr_reader :port
+
+      def accept
+        socket = nil
+        loop do
+          socket = super
+          break if !tcp_acl || tcp_acl.allow_socket?(socket) # TODO: not tested
+          socket.close
+        end
+
+        TCProtocol.apply_sockopt(socket)
+        BasicConnection.new(self, socket)
+      end
+
+      config_reader :tcp_acl
+      private :tcp_acl
+
+      def self.open_socket_inaddr_any(host, port)
+        infos = Socket.getaddrinfo(host, nil, Socket::AF_UNSPEC,
+                                   Socket::SOCK_STREAM, 0, Socket::AI_PASSIVE)
+        families = Hash[*infos.collect { |af, *_| af }.uniq.zip([]).flatten]
+        return TCPServer.open('0.0.0.0', port) if families.key?('AF_INET')
+        return TCPServer.open('::', port) if families.key?('AF_INET6')
+        TCPServer.open(port)
+      end
+    end
+  end
+end

data/lib/dizby/protocols/unix.rb

@@ -0,0 +1,95 @@
+
+require 'dizby/protocol/basic'
+require 'dizby/stream/client'
+require 'dizby/stream/connection'
+require 'dizby/server/basic'
+
+require 'socket'
+require 'tempfile'
+
+fail LoadError, 'UNIXServer is required' unless defined?(UNIXServer)
+
+module Dizby
+  class UnixProtocol
+    include BasicProtocol
+
+    self.scheme = 'drbunix'
+
+    refine(:server,
+           "#{scheme}:%{file}?"
+          ) do |front, config, (filename)|
+      Server.new front, config, filename
+    end
+
+    refine(:client,
+           "#{scheme}:%{file}%{query}?"
+          ) do |server, (filename, query)|
+      socket = UNIXSocket.open(filename)
+      UnixProtocol.apply_sockopt(socket)
+
+      client = BasicClient.new server, socket, "#{scheme}:#{filename}"
+      query &&= QueryRef.new(query)
+
+      [client, query]
+    end
+
+    def self.apply_sockopt(_soc)
+      # no-op for now
+    end
+
+    class Server < BasicServer
+      include PolymorphicDelegated
+
+      def initialize(front, config, filename)
+        unless filename
+          temp = Tempfile.new(%w( dizby-unix .socket ))
+          filename = temp.path
+          temp.close!
+        end
+
+        socket = UNIXServer.open(filename)
+        UnixProtocol.apply_sockopt(socket)
+
+        super("drbunix:#{filename}", front, socket, config)
+
+        self.class.set_permissions(filename, config)
+      end
+
+      def close
+        if stream
+          path = stream.path
+          stream.close
+          self.stream = nil
+
+          log.debug("unlinking #{path}")
+          File.unlink(path)
+        end
+
+        close_shutdown_pipe
+      end
+
+      def accept
+        socket = super
+
+        UnixProtocol.apply_sockopt(socket)
+        BasicConnection.new(self, socket)
+      end
+
+      def self.set_permissions(filename, config)
+        owner = config[:unix_owner]
+        group = config[:unix_group]
+        mode = config[:unix_mode]
+
+        if owner || group
+          require 'etc'
+          owner = Etc.getpwnam(owner).uid if owner
+          group = Etc.getgrnam(group).gid if group
+          File.chown(owner, group, filename)
+        end
+
+        File.chmod(mode, filename) if mode
+      end
+      private_class_method :set_permissions
+    end
+  end
+end