vcs 0.1 → 0.2.148

data/ruby_ex/drb/drb_service.rb

@@ -0,0 +1,43 @@
+# Author:: Nicolas Despres  <nicolas.despres@epita.fr>.
+# Copyright:: Copyright (c) 2004 TTK Team. All rights reserved.
+# License:: Ruby license.
+
+# $LastChangedBy: polrop $
+# $Id: drb_service.rb 137 2005-01-28 17:41:56Z polrop $
+
+
+require 'drb/drb'
+
+
+module DRb
+
+  class DRbService
+    include DRbUndumped
+
+    def initialize(config={})
+      @config = config
+      @server = nil
+      @uri = nil
+      @front = nil
+    end
+
+    attr_reader :server, :uri, :front
+
+    def start_service(uri)
+      @server = DRb.start_service(uri.nil? ? uri : uri.to_s, @front, @config)
+      @uri = URI.parse(@server.uri)
+    end
+
+    def stop_service
+      @server.stop_service if @server
+    end
+
+    def thread
+      @server.thread if @server
+    end
+
+  end # class DRbService
+
+end # module DRb
+
+

data/ruby_ex/drb/drb_undumped_attributes.rb

@@ -0,0 +1,55 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: drb_undumped_attributes.rb 88 2005-01-09 21:11:26Z polrop $
+
+
+require 'drb/drb'
+
+
+module DRb
+
+  module DRbUndumpedAttributes
+
+    def DRbUndumpedAttributes.append_features(cl)
+      super
+      cl.module_eval do
+
+        def _dump(depth)
+          if self.class.include?(DRb::DRbUndumped)
+            raise(TypeError, 'can\'t dump')
+          end
+          attribs = {}
+          instance_variables.each do |attr|
+            obj = instance_variable_get(attr)
+            begin
+              attribs[attr] = Marshal.dump(obj)
+            rescue TypeError
+              if (defined? LOG) and (not obj.class.include? DRb::DRbUndumped)
+                LOG.warn("#{self.class}._dump") do
+                  "can't dump a #{attr}:#{obj.class}"
+                end
+              end
+              attribs[attr] = Marshal.dump(DRbObject.new(obj))
+            end
+          end
+          Marshal.dump([self.class, attribs])
+        end
+
+        def self._load(data)
+          klass, attribs = Marshal.load(data)
+          obj = klass.new
+          attribs.each do |attr, value|
+            obj.instance_variable_set(attr, Marshal.load(value))
+          end
+          obj
+        end
+      end
+
+    end
+
+  end # module DRbUndumpedAttributes
+
+end # module DRb

data/ruby_ex/drb/drb_undumped_indexed_object.rb

@@ -0,0 +1,54 @@
+# Author:: Nicolas Despres  <nicolas.despres@epita.fr>.
+# Copyright:: Copyright (c) 2004 TTK Team. All rights reserved.
+# License:: Ruby license.
+
+# $LastChangedBy: polrop $
+# $Id: drb_undumped_indexed_object.rb 73 2004-12-09 18:24:52Z polrop $
+
+
+require 'drb'
+
+
+module DRb
+
+  module DRbUndumpedIndexedObject
+
+    def DRbUndumpedIndexedObject.append_features(cl)
+      super
+      cl.module_eval do
+
+        def _dump(depth)
+          if self.class.include?(DRb::DRbUndumped)
+            raise(TypeError, 'can\'t dump')
+          end
+          attribs = {}
+          each_pair do |k, v|
+            begin
+              attribs[k] = Marshal.dump(v)
+            rescue TypeError
+              if (defined? LOG) and (not v.class.include? DRb::DRbUndumped)
+                LOG.warn("#{self.class}._dump") do
+                  "can't dump a #{k}:#{v.class}"
+                end
+              end
+              attribs[k] = Marshal.dump(DRbObject.new(v))
+            end
+          end
+          Marshal.dump([self.class, attribs])
+        end
+
+        def self._load(data)
+          klass, attribs = Marshal.load(data)
+          obj = klass.new
+          attribs.each do |key, value|
+            obj[key] = Marshal.load(value)
+          end
+          obj
+        end
+      end
+
+    end
+
+  end # module DRbUndumpedIndexedObject
+
+end # module DRb

data/ruby_ex/drb/insecure_protected_methods.rb

@@ -0,0 +1,103 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: insecure_protected_methods.rb 88 2005-01-09 21:11:26Z polrop $
+
+
+require 'drb/drb'
+
+
+module DRb
+
+  class DRbServer
+
+    alias_method :ori_check_insecure_method, :check_insecure_method
+    def check_insecure_method(obj, msg_id)
+      ori_check_insecure_method(obj, msg_id)
+      if obj.protected_methods.include?(msg_id.to_s)
+        desc = any_to_s(obj)
+        if desc.nil? || desc[0] == '#'
+          desc << ":#{obj.class}"
+        end
+        raise NameError, "protected method `#{msg_id}' called for #{desc}"
+      end
+      true
+    end
+
+  end # class DRbServer
+
+end # module DRb
+
+
+#
+# Unit test suite
+#
+if defined? TEST_MODE or $0 == __FILE__
+
+
+require 'test/unit/ui/yaml/testrunner'
+
+
+module DRb
+
+  class InsecureProtectedMethodsTest < Test::Unit::TestCase
+
+    class SrvFoo
+
+      def public_request
+      end
+
+      protected
+      def protected_request
+      end
+
+    end # class Foo
+
+    def setup
+      rd, wr = IO.pipe
+      unless @srv_pid = fork # son
+        rd.close
+        DRb.start_service("druby://localhost:42000", SrvFoo.new)
+        wr.puts('ready')
+        wr.close
+        DRb.thread.join
+      else # father
+        wr.close
+        rd.gets
+        @drb_srv = DRb.start_service
+        @drb_obj = DRbObject.new(nil, "druby://localhost:42000")
+        rd.close
+      end
+    end
+
+    def teardown
+      @drb_srv.stop_service
+      Process.kill('TERM', @srv_pid)
+      Process.waitpid(@srv_pid)
+    end
+
+    #
+    # Test
+    #
+    def test_simple
+      assert_raises(NameError) { @drb_obj.send(:protected_resquest) }
+      assert_nothing_raised { @drb_obj.public_request }
+    end
+
+    #
+    # Tools
+    #
+    def server_request(req)
+    end
+
+  end # class InsecureProtectedMethodsTest
+
+
+end # module DRb
+
+
+end
+
+

data/ruby_ex/drb/session_client_test.rb

@@ -0,0 +1,40 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: session_client_test.rb 91 2005-01-09 22:24:40Z polrop $
+
+
+# Test client used by session_manager.
+if __FILE__ == $0
+
+  require 'drb/drb'
+
+  server = nil
+  service = nil
+  uri = ARGV.shift
+  num = ARGV.shift
+  name = ARGV.shift
+  begin
+    STDERR.puts "#{num}:A: start server" if $VERBOSE
+    server = DRb.start_service
+    STDERR.puts "#{num}:B: bind front" if $VERBOSE
+    front = DRb::DRbObject.new(nil, uri)
+    STDERR.puts "#{num}:C: start service" if $VERBOSE
+    service = front.service(name)
+  ensure
+    begin
+      STDERR.puts "#{num}:D: stop service" if $VERBOSE
+      service.stop_service unless service.nil?
+    rescue DRb::DRbConnError
+      STDERR.puts "#{num}: stop service too late" if $VERBOSE
+    ensure
+      STDERR.puts "#{num}:E: stop server" if $VERBOSE
+      server.stop_service unless server.nil?
+      STDERR.puts "#{num}:F: finish" if $VERBOSE
+    end
+  end
+
+end
+

data/ruby_ex/drb/session_manager.rb

@@ -0,0 +1,246 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: session_manager.rb 186 2005-04-03 00:07:45Z ertai $
+
+
+require 'drb/extservm.rb'
+
+
+module DRb
+
+  class SessionManager < ExtServManager
+
+    SESSION_LIMIT = 1024
+
+    class Error < RuntimeError; end
+    class FullError < Error; end
+
+    @@session_type = {}
+    @@mutex = Mutex.new
+
+    class << self
+
+      alias_method :super_command, :command
+      alias_method :super_command=, :command=
+
+      undef_method :super_command, :super_command=
+
+      def command
+        @@session_type
+      end
+
+      def command=
+        @@session_type = session_type
+      end
+
+      alias session_type command
+      alias session_type= command=
+
+    end
+
+    attr_reader   :nb_sessions, :total_session_started, :total_session_stoped
+    attr_accessor :session_limit
+
+    def initialize(session_limit=SESSION_LIMIT)
+      super()
+      @session_limit = session_limit
+      @nb_sessions = 0
+      @total_session_started = 0
+      @total_session_stoped = 0
+    end
+
+    def service(name)
+      raise("`#{name}' - invalid session type") unless @@session_type[name]
+      sid = nil
+      @@mutex.synchronize do
+        test_server_full
+        sid = gen_id("#{name}_#{Time.now.to_s.gsub!(/\s/, '_')}_") do |id|
+          @@command[id]
+        end
+        @@command[sid] = @@session_type[name]
+        super(sid)
+      end
+    end
+
+    def regist(sid, ro)
+      test_server_full
+      ret = super
+      @total_session_started += 1
+      @nb_sessions += 1
+      ret
+    end
+
+    def unregist(sid)
+      super
+      @@mutex.synchronize do
+        if @@command.delete(sid)
+          @total_session_stoped += 1
+          @nb_sessions -= 1
+        end
+      end
+    end
+
+    protected
+    def gen_id(base, &block)
+      c = 0
+      begin
+        id = base + c.to_s
+        c += 1
+      end while block[id]
+      id
+    end
+
+    protected
+    def test_server_full
+      raise(FullError, "server full") unless @nb_sessions < @session_limit
+    end
+
+  end # class SessionManager
+
+end # module DRb
+
+
+if defined? TEST_MODE or __FILE__ == $0
+
+require 'test/unit/ui/yaml/testrunner'
+require 'rbconfig'
+
+module DRb
+
+  class SessionManagerTest < ::Test::Unit::TestCase
+
+    def test_visibility
+      assert_respond_to(SessionManager, :command=)
+      assert_respond_to(SessionManager, :command)
+      assert_respond_to(SessionManager, :session_type=)
+      assert_respond_to(SessionManager, :session_type)
+      assert_raises(NoMethodError) { SessionManager.super_command }
+      assert_raises(NoMethodError) { SessionManager.super_command=(nil) }
+    end
+
+    def test_service
+      name, ruby_bin = add_command
+      drb_session_manager = DRb::SessionManager.new
+      server = DRb.start_service('druby://localhost:0',
+                                 drb_session_manager,
+                                 {})
+      assert_raises(RuntimeError) { drb_session_manager.service('foo') }
+      tester = drb_session_manager.service(name)
+      assert_match(Regexp.new("^#{name}"), tester.sid)
+      front = tester.front
+      assert_equal('hello', front.hello)
+      assert_equal('salut', front.salut)
+      tester.stop_service
+      server.stop_service
+    end
+
+    def test_service_full
+      name, ruby_bin = add_command
+      drb_session_manager = DRb::SessionManager.new
+      drb_session_manager.session_limit = 2
+      assert_equal(2, drb_session_manager.session_limit)
+      server = DRb.start_service('druby://localhost:0',
+                                 drb_session_manager,
+                                 {})
+
+      tester1 = drb_session_manager.service(name)
+      assert_match(Regexp.new("^#{name}"), tester1.sid)
+      front1 = tester1.front
+      assert_equal('hello', front1.hello)
+      assert_equal('salut', front1.salut)
+      assert_equal(1, drb_session_manager.nb_sessions)
+
+      tester2 = drb_session_manager.service(name)
+      assert_match(Regexp.new("^#{name}"), tester2.sid)
+      front2 = tester2.front
+      assert_equal('hello', front2.hello)
+      assert_equal('salut', front2.salut)
+      assert_equal(2, drb_session_manager.nb_sessions)
+
+      assert_raises(SessionManager::FullError) do
+        drb_session_manager.service(name)
+      end
+      tester2.stop_service
+      assert_equal(1, drb_session_manager.nb_sessions)
+      tester3 = nil
+      assert_nothing_raised { tester3 = drb_session_manager.service(name) }
+      assert_equal(2, drb_session_manager.nb_sessions)
+      tester3.stop_service
+      assert_equal(1, drb_session_manager.nb_sessions)
+      tester1.stop_service
+      assert_equal(0, drb_session_manager.nb_sessions)
+      server.stop_service
+    end
+
+    def test_several_local_client
+      name, ruby_bin, chdir = add_command
+      drb_session_manager = SessionManager.new
+      server = DRb.start_service('druby://localhost:0',
+                                 drb_session_manager,
+                                 {})
+      services = []
+      nb_clients = 10
+      nb_clients.times do |i|
+        services << drb_session_manager.service(name)
+      end
+      until (n = drb_session_manager.nb_sessions) == nb_clients
+        STDERR.puts "wait for #{n} sessions started" if $VERBOSE
+        sleep(2)
+      end
+      services.each do |service|
+        assert_equal('hello', service.front.hello)
+        assert_equal('salut', service.front.salut)
+      end
+      services.each do |service|
+        service.stop_service
+      end
+      while (n = drb_session_manager.nb_sessions) > 0
+        STDERR.puts "wait for #{n} sessions stoped" if $VERBOSE
+        sleep(2)
+      end
+      server.stop_service
+    end
+
+    def test_non_local_client
+      name, ruby_bin, chdir = add_command
+      drb_session_manager = SessionManager.new
+      server = DRb.start_service('druby://localhost:0',
+                                 drb_session_manager,
+                                 {})
+      nb_clients = 10
+      cmd = chdir + "#{ruby_bin} drb/session_client_test.rb"
+      nb_clients.times do |i|
+        system("#{cmd} #{server.uri} #{i} #{name} &")
+      end
+      until (n = drb_session_manager.total_session_started) == nb_clients
+        STDERR.puts "wait for #{n} sessions started" if $VERBOSE
+        sleep(2)
+      end
+      until (n = drb_session_manager.total_session_stoped) == nb_clients
+        STDERR.puts "wait for #{n} sessions stoped" if $VERBOSE
+        sleep(2)
+      end
+      STDERR.puts 'stop service' if $VERBOSE
+      server.stop_service
+    end
+
+    protected
+    def add_command
+      ruby_bin = Config::CONFIG["RUBY_INSTALL_NAME"]
+      ruby_bin += ' -w' if $VERBOSE
+      name = "session_server"
+      chdir = (defined? TEST_MODE) ? "cd src;" : ''
+      cmd = chdir + "#{ruby_bin} drb/#{name}.rb"
+      DRb::SessionManager.command[name] = cmd
+      [ name, ruby_bin, chdir ]
+    end
+
+  end # class SessionManagerTest
+
+end # module DRb
+
+end
+