dizby 1.3.0

data/lib/dizby/server/abstract.rb

@@ -0,0 +1,42 @@
+
+require 'dizby/protocol/manager'
+require 'dizby/distributed/object'
+require 'dizby/utility/configurable'
+require 'dizby/utility/log'
+
+module Dizby
+  class AbstractServer
+    extend Configurable
+
+    def initialize(config, &log_transform)
+      @config = config
+      @log = Dizby.create_logger(config[:logging], &log_transform)
+    end
+
+    attr_reader :log
+    config_reader :load_limit
+
+    def connect_to(uri)
+      ProtocolManager.open_client(self, uri)
+    end
+
+    def spawn_on(command, uri)
+      ProtocolManager.spawn_server(self, command, uri)
+    end
+
+    def shutdown; end
+
+    def alive?
+      true
+    end
+
+    def make_distributed(obj, error)
+      if error
+        RemoteDistributedError.new(obj)
+      else
+        log.debug("making distributed: #{obj.inspect}")
+        DistributedObject.new(obj, self)
+      end
+    end
+  end
+end

data/lib/dizby/server/basic.rb

@@ -0,0 +1,101 @@
+
+require 'dizby/stream/query_ref'
+require 'dizby/utility/polymorphic_delegated'
+require 'dizby/utility/self_pipe'
+require 'dizby/utility/monitor'
+
+require 'io/wait'
+
+module Dizby
+  class BasicServer < AbstractServer
+    extend ClassicAttributeAccess
+
+    def initialize(uri, front, stream, config)
+      super(config) { |msg| "#{uri} : #{msg}" }
+
+      @uri = uri
+      @front = front
+      @stream = stream
+
+      @exported_uri = Dizby.monitor([@uri])
+
+      @shutdown_pipe = SelfPipe.new(*IO.pipe)
+    end
+
+    def close
+      log.debug('Closing')
+      if stream
+        stream.close
+        self.stream = nil
+      end
+
+      close_shutdown_pipe
+    end
+
+    def shutdown
+      log.debug('Shutting down')
+      shutdown_pipe.close_write if shutdown_pipe
+    end
+
+    def accept
+      readables, = IO.select([stream, shutdown_pipe.read])
+      fail LocalServerShutdown if readables.include? shutdown_pipe.read
+      log.debug('Accepting connection')
+      stream.accept
+    end
+
+    def alive?
+      return false unless stream
+      return true if stream.ready?
+
+      shutdown
+      false
+    end
+
+    def to_obj(ref)
+      case ref
+      when nil
+        front
+      when QueryRef
+        front[ref.to_s]
+      else
+        idconv.to_obj(ref)
+      end
+    end
+
+    def to_id(obj)
+      return nil if obj.__id__ == front.__id__
+      idconv.to_id(obj)
+    end
+
+    attr_reader :uri
+    config_reader :argc_limit
+
+    def add_uri_alias(uri)
+      log.debug("Adding uri alias: #{uri}")
+
+      exported_uri.synchronize do
+        exported_uri << uri unless exported_uri.include?(uri)
+      end
+    end
+
+    def here?(uri)
+      exported_uri.synchronize { exported_uri.include?(uri) }
+    end
+
+    private
+
+    config_reader :idconv
+    attr_reader :front, :exported_uri
+    attr_accessor :stream, :shutdown_pipe
+
+    def close_shutdown_pipe
+      return nil unless shutdown_pipe
+
+      log.debug('Closing shutdown pipe')
+      shutdown_pipe.close_read
+      shutdown_pipe.close_write
+      self.shutdown_pipe = nil
+    end
+  end
+end

data/lib/dizby/server/registration.rb

@@ -0,0 +1,23 @@
+
+require 'dizby/utility/monitor'
+
+module Dizby
+  @servers = Dizby.monitor([])
+
+  def self.register_server(server)
+    @servers.synchronize { @servers << server }
+  end
+
+  def self.unregister_server(server)
+    @servers.synchronize { @servers.delete(server) }
+  end
+
+  # returns [success, object]
+  def self.get_obj(uri, ref)
+    @servers.synchronize do
+      local_server = @servers.find { |server| server && server.here?(uri) }
+
+      [!local_server.nil?, local_server && local_server.to_obj(ref)]
+    end
+  end
+end

data/lib/dizby/service.rb

@@ -0,0 +1,64 @@
+
+require 'dizby/protocol/manager'
+require 'dizby/converter/simple'
+require 'dizby/worker/server'
+require 'dizby/utility/log'
+
+module Dizby
+  class Service
+    def initialize(uri = '', front = nil, config = {})
+      config = DEFAULT_CONFIG.merge(config)
+
+      self.server = ProtocolManager.open_server(uri, front, config)
+    rescue NonAcceptingServer => err
+      # This is to allow servers that don't accept connections
+      # Not all servers will allow connections back to them, so don't allow it
+      self.server = err.server
+      @server.log.warn('using a server that does not allow connections')
+    else
+      @worker = ServiceWorker.new(@server)
+    ensure
+      Dizby.register_server(@server)
+    end
+
+    def connect_to(uri)
+      ObjectProxy.new(*@server.connect_to(uri))
+    end
+
+    def spawn_on(command, uri)
+      ObjectProxy.new(*@server.spawn_on(command, uri))
+    end
+
+    def close
+      Dizby.unregister_server @server
+      return unless alive?
+      @server.shutdown
+    end
+
+    def alive?
+      @server.alive?
+    end
+
+    def wait
+      @worker.join if @worker
+    end
+
+    DEFAULT_CONFIG = {
+      idconv: IdConverter,
+      argc_limit: 256,
+      load_limit: 256 * 1024 * 100,
+      logging: {
+        level: Logger::ERROR,
+        output: $stderr
+      },
+      tcp_acl: nil
+    }
+
+    private
+
+    def server=(srvr)
+      fail DistributedError, 'server could not be opened' unless srvr
+      @server = srvr
+    end
+  end
+end

data/lib/dizby/stream/client.rb

@@ -0,0 +1,26 @@
+
+require 'dizby/stream/messenger'
+
+module Dizby
+  class BasicClient < Messenger
+    def initialize(server, stream, remote_uri)
+      super(server, stream)
+
+      @remote_uri = remote_uri
+
+      # write the other side's remote_uri to the socket
+      write(dump_data(@remote_uri))
+    end
+
+    def send_request(ref, msg_id, *args, &block)
+      arr = [ref, msg_id.id2name, args.length, *args, block]
+      arr.map! { |ele| dump_data(ele) }
+      write(arr.join(''))
+    end
+
+    def recv_reply
+      succ, result = 2.times.map { read }
+      [succ, result]
+    end
+  end
+end

data/lib/dizby/stream/connection.rb

@@ -0,0 +1,63 @@
+
+require 'dizby/stream/messenger'
+require 'dizby/utility/self_pipe'
+
+module Dizby
+  class BasicConnection < Messenger
+    def initialize(server, stream)
+      super(server, stream)
+
+      # get the uri that the client recognizes the server as
+      @remote_uri = read
+
+      @shutdown_pipe = SelfPipe.new(*IO.pipe)
+      @object_space = []
+    end
+
+    def recv_request
+      wait_for_stream
+
+      ref, msg, argc = 3.times.map { read }
+
+      @server.log.debug("called through proxy: #{ref} #{msg}")
+      fail ConnectionError, 'too many arguments' if @server.argc_limit < argc
+
+      argv = Array.new(argc) { read }
+      block = read
+
+      ro = @server.to_obj(ref)
+      [ro, msg, argv, block]
+    end
+
+    def send_reply(succ, result)
+      write(dump_data(succ) + dump_data(result, !succ))
+    rescue
+      raise ConnectionError, $!.message, $!.backtrace
+    end
+
+    def close
+      @object_space.clear
+      shutdown_pipe.close_write if shutdown_pipe
+      super
+    end
+
+    private
+
+    # when a distributed object is made through a connection, store it
+    # so that it doesn't get consumed by the garbage collector
+    def make_distributed(_obj, _error)
+      distributed = super
+      @object_space << distributed
+      distributed
+    end
+
+    def wait_for_stream
+      readable, = IO.select([@stream, shutdown_pipe.read])
+      fail RemoteServerShutdown if readable.include?(shutdown_pipe.read)
+    rescue IOError
+      raise RemoteServerShutdown
+    end
+
+    attr_reader :shutdown_pipe
+  end
+end

data/lib/dizby/stream/messenger.rb

@@ -0,0 +1,28 @@
+
+require 'dizby/stream/readable'
+require 'dizby/stream/writable'
+
+module Dizby
+  class Messenger
+    include ReadableStream
+    include WritableStream
+
+    def initialize(server, stream)
+      @server = server
+
+      # stream needs to have the read(int), write(str), and close() methods
+      # this value can be overloaded in the client/server classes for a protocol
+      @stream = stream
+    end
+
+    attr_reader :server, :remote_uri
+
+    def close
+      @stream.close
+    end
+
+    def closed?
+      !@stream || @stream.closed?
+    end
+  end
+end

data/lib/dizby/stream/query_ref.rb

@@ -0,0 +1,13 @@
+
+module Dizby
+  # Acts as an array or hash index to a remote object
+  class QueryRef
+    def initialize(query)
+      @query = query
+    end
+
+    def to_s
+      @query.to_s
+    end
+  end
+end

data/lib/dizby/stream/readable.rb

@@ -0,0 +1,65 @@
+
+require 'dizby/distributed/semi_proxy'
+
+module Dizby
+  module ReadableStream
+    def read
+      sz = check_packet_size(load_size)
+      str = load_packet(sz)
+
+      fail ConnectionError, 'connection closed' unless str
+
+      if str.size < sz
+        fail ConnectionError, 'premature marshal format(can\'t read)'
+      end
+
+      load_obj(str)
+
+      # TODO: un-tainting???
+    end
+
+    private
+
+    def load_size
+      @stream.read(4)
+    rescue
+      raise ConnectionError, $!.message, $!.backtrace
+    end
+
+    def load_packet(sz)
+      @stream.read(sz)
+    rescue
+      raise ConnectionError, $!.message, $!.backtrace
+    end
+
+    def load_obj(marshalled_str)
+      @server.log.debug("loading data: #{marshalled_str.inspect}")
+      obj = Marshal.load(marshalled_str)
+      @server.log.debug("loaded: #{obj.inspect}")
+
+      # get a local object or create the proxy using the current server
+      # done here since marshalling doesn't know about the current server
+      obj = obj.evaluate(@server) if obj.is_a?(SemiObjectProxy)
+
+      obj
+    rescue NameError, ArgumentError
+      @server.log.debug("unknown: #{$!.inspect} #{$!.backtrace}")
+      UnknownObject.new($!, marshalled_str)
+    end
+
+    def check_packet_size(sz)
+      fail RemoteServerShutdown unless sz
+      fail ConnectionError, 'premature header' if sz.size < 4
+
+      sz = sz.unpack('N')[0]
+
+      # load_limit must be greater than the size of the packet
+      # or the load_limit can be 0 or less to be considered "infinite"
+      if @server.load_limit.between?(0, sz)
+        fail ConnectionError, "too large packet for #{sz}"
+      end
+
+      sz
+    end
+  end
+end

data/lib/dizby/stream/writable.rb

@@ -0,0 +1,37 @@
+
+require 'dizby/distributed/undumpable'
+
+module Dizby
+  module WritableStream
+    def write(data)
+      @stream.write(data)
+    end
+
+    def dump_data(obj, error = false)
+      @server.log.debug("dumping: #{obj.inspect}")
+
+      if obj.is_a?(UndumpableObject)
+        @server.log.debug('dumping undumpable')
+        obj = make_distributed(obj, error)
+      end
+
+      str = dump_obj(obj, error)
+      @server.log.debug("dumped: #{str.inspect}")
+
+      [str.size].pack('N') + str
+    end
+
+    private
+
+    def dump_obj(obj, error)
+      Marshal.dump(obj)
+    rescue
+      @server.log.debug('rescuing and dumping pseudo-undumpable...')
+      Marshal.dump(make_distributed(obj, error))
+    end
+
+    def make_distributed(obj, error)
+      @server.make_distributed(obj, error)
+    end
+  end
+end