r2corba 1.5.1-universal-java

data/test/Timeout/run_test.rb

@@ -0,0 +1,69 @@
+#--------------------------------------------------------------------
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+OPTIONS = {
+  :debug_opt => '',
+  :use_implement => '--use-implement'
+}
+
+require 'optparse'
+
+ARGV.options do |opts|
+    script_name = File.basename($0)
+    opts.banner = "Usage: ruby #{script_name} [options]"
+
+    opts.separator ""
+
+    opts.on("-d",
+            "Run with debugging output.",
+            "Default: false") { OPTIONS[:debug_opt] = '--d 10' }
+    opts.on("--use-stubs",
+            "Use stubs generated by RIDL.",
+            "Default: false (uses embedded IDL)") { OPTIONS[:use_implement] = '' }
+
+    opts.separator ""
+
+    opts.on("-h", "--help",
+            "Show this help message.") { puts opts; exit }
+
+    opts.parse!
+end
+
+require 'lib/test.rb'
+include TestUtil
+
+ior_file = 'server.ior'
+
+TestUtil.remove_file(ior_file)
+
+srv = Test.new
+
+exit(255) if !srv.run('server.rb', "--o #{ior_file} #{OPTIONS[:debug_opt]} #{OPTIONS[:use_implement]}")
+
+TestUtil.wait_for_file(ior_file, 400)
+
+clt = Test.new
+
+if !clt.run('client.rb', "--k file://#{ior_file} #{OPTIONS[:debug_opt]} #{OPTIONS[:use_implement]}")
+  srv.kill(100)
+  exit(255)
+end
+
+exrc = clt.wait(400)
+
+if exrc ==0
+  srv.wait(400)
+else
+  srv.wait_term(400)
+end
+
+exit(exrc)

data/test/Timeout/server.ior

@@ -0,0 +1 @@
+IOR:000000000000001649444C3A53696D706C655F5365727665723A312E300000000000000100000000000000EC000102000000000B31302E342E302E3132300000B5DC00000000001F353132303437373232332F00154000463C0D3429100630463814141B484C1B0000000004000000030000002E0000000000000024323030313A3938323A613037323A313A643236373A653566663A666534393A3130333400B5DC0000000000030000002E0000000000000023323030313A3938323A613037323A313A333165393A3238393A323764333A343061610000B5DC00000000000000000008000000004A4143000000000100000024000000000501000100000002000100010001000F00010109000000020501000100010100

data/test/Timeout/server.rb

@@ -0,0 +1,109 @@
+#--------------------------------------------------------------------
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+require 'optparse'
+
+OPTIONS = {
+  :use_implement => false,
+  :orb_debuglevel => 0,
+  :iorfile => 'server.ior',
+  :iter_num => 10
+}
+
+ARGV.options do |opts|
+    script_name = File.basename($0)
+    opts.banner = "Usage: ruby #{script_name} [options]"
+
+    opts.separator ""
+
+    opts.on("--o IORFILE",
+            "Set IOR filename.",
+            "Default: 'server.ior'") { |v| OPTIONS[:iorfile]=v }
+    opts.on("--d LVL",
+            "Set ORBDebugLevel value.",
+            "Default: 0") { |v| OPTIONS[:orb_debuglevel]=v }
+    opts.on("--use-implement",
+            "Load IDL through CORBA.implement() instead of precompiled code.",
+            "Default: off") { |v| OPTIONS[:use_implement]=v }
+    opts.on("--i ITERATIONS",
+            "Set number of iterations.",
+            "Default: 10", Integer) { |v| OPTIONS[:iter_num]=v }
+
+    opts.separator ""
+
+    opts.on("-h", "--help",
+            "Show this help message.") { puts opts; exit }
+
+    opts.parse!
+end
+
+if OPTIONS[:use_implement]
+  require 'corba/poa.rb'
+  CORBA.implement('test.idl', OPTIONS, CORBA::IDL::SERVANT_INTF)
+else
+  require 'testS.rb'
+end
+
+class Simple_Server_i < POA::Simple_Server
+  def initialize(orb)
+    @orb = orb
+  end
+
+  def echo(x, msecs)
+    sleep_time = msecs / 1000.0
+
+    puts "server (#{Process.pid}) will request sleep for #{sleep_time.to_s} sec"
+
+    t = Time.now
+    sleep(sleep_time)
+
+    puts "server (#{Process.pid}) actually slept for #{(Time.now - t).to_s} sec"
+
+    return x
+  end
+
+  def shutdown()
+    puts "server (#{Process.pid}) received shutdown request from client"
+    @orb.shutdown()
+  end
+end #of servant Simple_Server_i
+
+orb = CORBA.ORB_init(["-ORBDebugLevel", OPTIONS[:orb_debuglevel]], 'myORB')
+
+obj = orb.resolve_initial_references('RootPOA')
+
+root_poa = PortableServer::POA._narrow(obj)
+
+poa_man = root_poa.the_POAManager
+
+poa_man.activate
+
+simple_srv = Simple_Server_i.new(orb)
+
+simple_ref = simple_srv._this()
+
+ior = orb.object_to_string(simple_ref)
+
+open(OPTIONS[:iorfile], 'w') { |io|
+  io.write ior
+}
+
+Signal.trap('INT') do
+  puts "SIGINT - shutting down ORB..."
+  orb.shutdown()
+end
+
+if Signal.list.has_key?('USR2')
+  Signal.trap('USR2', 'EXIT')
+end
+
+orb.run()

data/test/Timeout/test.idl

@@ -0,0 +1,19 @@
+/*--------------------------------------------------------------------
+ * Author: Martin Corino
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the R2CORBA LICENSE which is
+ * included with this program.
+ *
+ * Copyright (c) Remedy IT Expertise BV
+ * Chamber of commerce Rotterdam nr.276339, The Netherlands
+ *--------------------------------------------------------------------*/
+
+interface Simple_Server {
+
+  /// Returns <x>, but sleep for <msecs> milliseconds before returning
+  long echo (in long x, in long msecs);
+
+  /// Shutdown the ORB
+  oneway void shutdown ();
+};

data/test/lib/assert.rb

@@ -0,0 +1,43 @@
+#--------------------------------------------------------------------
+# assert.rb - simple assertion testers
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+module TestUtil
+
+  module Assertions
+    def assert(message = 'Assertion failed', boolean = nil, &block)
+      raise ArgumentError, '#assert requires a boolean or a block' unless !boolean.nil? or block_given?
+      boolean = yield if boolean.nil?
+      raise message unless boolean
+    end
+
+    def assert_not(message = 'Assertion failed', boolean = nil, &block)
+      raise ArgumentError, '#assert_not requires a boolean or a block' unless !boolean.nil? or block_given?
+      boolean = yield if boolean.nil?
+      raise message unless !boolean
+    end
+
+    def assert_except(message = 'Assertion failed', exception = Exception, &block)
+      raise ArgumentError, '#assert_except requires a block' unless block_given?
+      begin
+        yield
+      rescue exception => ex_
+        return # this should happen
+      rescue
+        raise "caught #{$!}\n#{message}"
+      end
+      raise message
+    end
+  end
+
+end
+

data/test/lib/test.rb

@@ -0,0 +1,542 @@
+#--------------------------------------------------------------------
+# test.rb - Test running utils
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+require 'rbconfig'
+
+module TestUtil
+
+  if defined? RbConfig
+    RB_CONFIG = RbConfig::CONFIG
+  else
+    RB_CONFIG = Config::CONFIG
+  end
+
+  def self.is_win32?
+    (RB_CONFIG['target_os'] =~ /win32/ || RB_CONFIG['target_os'] =~ /mingw32/) ? true : false
+  end
+
+  RBVersion = RUBY_VERSION.split('.').collect {|x| x.to_i}
+end
+
+
+if defined?(JRUBY_VERSION)
+  require 'ffi'
+elsif TestUtil::is_win32?
+  unless TestUtil::RBVersion[0] >= 2 || TestUtil::RBVersion[1] > 8
+    # get Win32 Process support
+    require 'rubygems'
+    gem 'windows-pr', '>= 1.2.2'
+    require 'windows/api'
+    require 'windows/process'
+    require 'windows/error'
+    require 'windows/library'
+    require 'windows/console'
+    require 'windows/handle'
+    require 'windows/synchronize'
+    require 'windows/thread'
+  end
+end
+
+module TestUtil
+
+  class ProcessError < RuntimeError; end
+
+if defined?(JRUBY_VERSION)
+  class Process
+    JRUBY_CMD = File.join(RB_CONFIG['bindir'], RB_CONFIG['RUBY_INSTALL_NAME']).sub(/.*\s.*/m, '"\&"')
+  protected
+    module Exec
+      extend FFI::Library
+      ffi_lib 'c'
+
+      if TestUtil::is_win32?
+
+        # intptr_t _spawnvpe(int mode,
+        #                    const char *cmdname,
+        #                    const char *const *argv,
+        #                    const char *const *envp);
+
+        attach_function :_spawnvpe,:_spawnvpe, [:int, :string, :pointer, :pointer], :pointer
+
+        P_NOWAIT = 1
+
+        # intptr_t _cwait(int *termstat,
+        #                 intptr_t procHandle,
+        #                 int action);
+
+        attach_function :_wait, :_cwait, [:pointer, :pointer, :int], :pointer
+
+        module Kernel32
+          extend FFI::Library
+          ffi_lib 'kernel32'
+          ffi_convention :stdcall
+
+          attach_function :terminate_process, :TerminateProcess, [:pointer, :uint], :int
+        end
+
+        def self.run(cmd, args)
+          argv = ['cmd', '/c']
+          argv << "cd #{Dir.getwd.gsub('/', '\\')} && #{Process::JRUBY_CMD} #{$VERBOSE ? '-v' : ''} #{cmd} #{args}"
+          spawnp(*argv)
+        end
+
+        def self.spawnp(*args)
+          spawn_args = _prepare_spawn_args(args)
+          _spawnvpe(*spawn_args)
+        end
+
+        def self.stop(pid)
+          kill(pid)
+        end
+
+        def self.kill(pid)
+          Kernel32.terminate_process(pid, 0) if pid
+        end
+
+        def self.wait(pid)
+          stat_ptr = FFI::MemoryPointer.new(:int, 1)
+          tmp_pid = _wait(stat_ptr, pid, 0)
+          if tmp_pid==pid
+            return [pid, stat_ptr.get_int()]
+          else
+            return [pid, 0]
+          end
+        end
+
+        private
+
+        def self._prepare_spawn_args(args)
+          args_ary = FFI::MemoryPointer.new(:pointer, args.length + 1)
+          str_ptrs = args.map {|str| FFI::MemoryPointer.from_string(str)}
+          args_ary.put_array_of_pointer(0, str_ptrs)
+
+          env_ary = FFI::MemoryPointer.new(:pointer, ENV.length + 1)
+          env_ptrs = ENV.map {|key,value| FFI::MemoryPointer.from_string("#{key}=#{value}")}
+          env_ary.put_array_of_pointer(0, env_ptrs)
+
+          [P_NOWAIT, args[0], args_ary, env_ary]
+        end
+      else
+        # Extracted from the Spoon gem by Charles Oliver Nutter
+
+        # int
+        # posix_spawnp(pid_t *restrict pid, const char *restrict path,
+        #     const posix_spawn_file_actions_t *file_actions,
+        #     const posix_spawnattr_t *restrict attrp, char *const argv[restrict],
+        #     char *const envp[restrict]);
+
+        attach_function :_posix_spawnp, :posix_spawnp, [:pointer, :string, :pointer, :pointer, :pointer, :pointer], :int
+
+        def self.run(cmd, args)
+          argv = ['sh', '-c']
+          argv << "cd #{Dir.getwd} && #{Process::JRUBY_CMD} #{$VERBOSE ? '-v' : ''} #{cmd} #{args}"
+          spawnp(*argv)
+        end
+
+        def self.spawnp(*args)
+          spawn_args = _prepare_spawn_args(args)
+          _posix_spawnp(*spawn_args)
+          spawn_args[0].read_int
+        end
+
+        def self.stop(pid)
+          ::Process.kill('TERM', pid) if pid
+        end
+
+        def self.kill(pid)
+          ::Process.kill('KILL', pid) if pid
+        end
+
+        def self.wait(pid)
+          begin
+            tmp, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
+            if tmp==pid and status.success? != nil
+              return [pid, status.success?() ? 0 : status.exitstatus ]
+            end
+            return [nil, 0]
+          rescue Errno::ECHILD
+            return [pid, 0]
+          end
+        end
+
+        private
+
+        def self._prepare_spawn_args(args)
+          pid_ptr = FFI::MemoryPointer.new(:pid_t, 1)
+
+          args_ary = FFI::MemoryPointer.new(:pointer, args.length + 1)
+          str_ptrs = args.map {|str| FFI::MemoryPointer.from_string(str)}
+          args_ary.put_array_of_pointer(0, str_ptrs)
+
+          env_ary = FFI::MemoryPointer.new(:pointer, ENV.length + 1)
+          env_ptrs = ENV.map {|key,value| FFI::MemoryPointer.from_string("#{key}=#{value}")}
+          env_ary.put_array_of_pointer(0, env_ptrs)
+
+          [pid_ptr, args[0], nil, nil, args_ary, env_ary]
+        end
+      end
+    end
+    def initialize(cmd_, arg_)
+      @pid = nil
+      @exitstatus = nil
+      @trd = Thread.start() do
+        exit_status = 0
+        @pid = Exec.run(cmd_, arg_)
+        if @pid
+          is_running = true
+          while is_running
+            sleep 0.01
+
+            tmp_pid, tmp_status = Exec.wait(@pid)
+            if tmp_pid==@pid
+              exit_status = tmp_status
+              is_running = false
+            end
+          end
+        end
+        exit_status
+      end
+    end
+  public
+    private_class_method :new
+
+    def Process.run(cmd_, arg_)
+      proc = new(cmd_, arg_)
+      sleep(0.1)
+      proc.check_status
+      return proc
+    end
+
+    def pid
+      @pid
+    end
+
+    def check_status
+      begin
+        unless @trd.alive?
+          @exitstatus = @trd.value
+        end
+        return @trd.alive?
+      rescue
+        @exitstatus = 0
+        return false
+      end
+    end
+
+    def exitstatus
+      @exitstatus
+    end
+
+    def is_running?; @exitstatus.nil?; end
+    def has_error? ; @trd.status.nil? or (!self.is_running? and self.exitstatus!=0) ;end
+
+    def stop
+      Exec.stop(@pid)
+    end
+
+    def kill
+      Exec.kill(@pid)
+    end
+  end # Process
+elsif is_win32? && TestUtil::RBVersion[0] < 2 && TestUtil::RBVersion[1] < 9
+    class Process
+      include Windows::Error
+      include Windows::Library
+      include Windows::Console
+      include Windows::Handle
+      include Windows::Synchronize
+      include Windows::Thread
+      extend Windows::Error
+      extend Windows::Library
+      extend Windows::Console
+      extend Windows::Handle
+      extend Windows::Synchronize
+      extend Windows::Thread
+
+    protected
+      # Used by Process.create
+      ProcessInfo = Struct.new("ProcessInfo",
+          :process_handle,
+          :thread_handle,
+          :process_id,
+          :thread_id
+      )
+
+      module WinAPI
+        Windows::API.auto_namespace = 'TestUtil::Process::WinAPI'
+        Windows::API.auto_constant = true
+        Windows::API.auto_method = true
+        Windows::API.auto_unicode = true
+
+        STILL_ACTIVE = 259
+
+        Windows::API.new('CreateProcess', 'PPPPLLLPPP', 'B')
+        Windows::API.new('GetExitCodeProcess', 'LP', 'B')
+      end
+
+      include WinAPI
+      extend WinAPI
+
+      def Process.create(cmd_)
+        startinfo = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+        startinfo = startinfo.pack('LLLLLLLLLLLLSSLLLL')
+        procinfo  = [0,0,0,0].pack('LLLL')
+
+        bool = CreateProcess(
+           0,                 # App name
+           cmd_,              # Command line
+           0,                 # Process attributes
+           0,                 # Thread attributes
+           1,                 # Inherit handles?
+           0,                 # Creation flags
+           0,                 # Environment
+           0,                 # Working directory
+           startinfo,         # Startup Info
+           procinfo           # Process Info
+        )
+
+        unless bool
+           raise ProcessError, "CreateProcess() failed: ", get_last_error
+        end
+
+        ProcessInfo.new(
+           procinfo[0,4].unpack('L').first, # hProcess
+           procinfo[4,4].unpack('L').first, # hThread
+           procinfo[8,4].unpack('L').first, # hProcessId
+           procinfo[12,4].unpack('L').first # hThreadId
+        )
+      end
+
+      def Process.waitpi(pi_)
+        exit_code = [0].pack('L')
+        if GetExitCodeProcess(pi_.process_handle, exit_code)
+          exit_code = exit_code.unpack('L').first
+          return exit_code == STILL_ACTIVE ? nil : exit_code
+        else
+          CloseHandle(pi_.process_handle) unless pi_.process_handle == INVALID_HANDLE_VALUE
+          pi_.process_handle = INVALID_HANDLE_VALUE
+          raise ProcessError, "GetExitCodeProcess failed: ", get_last_error
+        end
+      end
+
+      def Process.stop(pi_)
+        if pi_.process_handle != INVALID_HANDLE_VALUE
+          thread_id = [0].pack('L')
+          dll       = 'kernel32'
+          proc      = 'ExitProcess'
+
+          mh = GetModuleHandle(dll)
+          pa = GetProcAddress(mh, proc)
+          thread = CreateRemoteThread(
+              pi_.process_handle,
+              0,
+              0,
+              pa,
+              0,
+              0,
+              thread_id
+          )
+
+          if thread
+              WaitForSingleObject(thread, 5)
+              CloseHandle(pi_.process_handle)
+              pi_.process_handle = INVALID_HANDLE_VALUE
+          else
+              CloseHandle(pi_.process_handle)
+              pi_.process_handle = INVALID_HANDLE_VALUE
+              raise ProcessError, get_last_error
+          end
+        end
+      end
+
+      def Process.kill(pi_)
+        if pi_.process_handle != INVALID_HANDLE_VALUE
+          if TerminateProcess(pi_.process_handle, pi_.process_id)
+            CloseHandle(pi_.process_handle)
+            pi_.process_handle = INVALID_HANDLE_VALUE
+          else
+            CloseHandle(pi_.process_handle)
+            pi_.process_handle = INVALID_HANDLE_VALUE
+            raise ProcessError, get_last_error
+          end
+        end
+      end
+
+      def initialize(pi_)
+        @pi = pi_
+        @exitstatus = nil
+      end
+    public
+      private_class_method :new
+      def Process.run(cmd_, arg_)
+        pi = self.create("#{RB_CONFIG['RUBY_INSTALL_NAME']} #{$VERBOSE ? '-v' : ''} #{cmd_} #{arg_}")
+        proc = new(pi)
+        sleep(0.1)
+        proc.check_status
+        return proc
+      end
+
+      def pid; @pi.process_id; end
+
+      def check_status
+        @exitstatus ||= self.class.waitpi(@pi)
+        return @exitstatus.nil?
+      end
+
+      def exitstatus; @exitstatus; end
+
+      def is_running?; @exitstatus.nil?; end
+      def has_error?; !@exitstatus.nil? and (@exitstatus != 0); end
+
+      def stop
+        self.class.stop(@pi)
+        @exitstatus = 0
+      end
+
+      def kill
+        self.class.kill(@pi)
+      end
+    end # Process
+else # !win32
+  class Process
+  protected
+    def initialize(pid_)
+      @pid = pid_
+      @status = nil
+      @exitstatus = nil
+    end
+  public
+    private_class_method :new
+    unless TestUtil::RBVersion[0] >= 2 || TestUtil::RBVersion[1] > 8
+      def Process.run(cmd_, arg_)
+        pid = ::Process.fork do
+          ::Kernel.exec("#{RB_CONFIG['RUBY_INSTALL_NAME']} #{$VERBOSE ? '-v' : ''} #{cmd_} #{arg_}")
+        end
+        proc = new(pid)
+        sleep(0.1)
+        proc.check_status
+        return proc
+      end
+    else
+      def Process.run(cmd_, arg_)
+        pid = ::Kernel.spawn("#{RB_CONFIG['RUBY_INSTALL_NAME']} #{$VERBOSE ? '-v' : ''} #{cmd_} #{arg_}")
+        proc = new(pid)
+        sleep(0.1)
+        proc.check_status
+        return proc
+      end
+    end
+
+    attr_reader :pid
+
+    def check_status
+      begin
+        tmp, @status = ::Process.waitpid2(@pid, ::Process::WNOHANG)
+        if tmp==@pid and @status.success? == false
+          @exitstatus = @status.exitstatus
+          return false
+        end
+        return true
+      rescue Errno::ECHILD
+        @exitstatus = 0
+        return false
+      end
+    end
+
+    def exitstatus
+      @exitstatus
+    end
+
+    def is_running?; @exitstatus.nil?; end
+    def has_error?; !@status.nil? and (@status.success? == false); end
+
+    def stop
+      ::Process.kill('SIGTERM', @pid)
+    end
+
+    def kill
+      ::Process.kill('SIGKILL', @pid)
+    end
+  end # Process
+end
+
+  class Test
+    def initialize
+      @proc = nil
+      @cmd = ""
+    end
+
+    def run(cmd_, arg_)
+      @cmd = cmd_
+      begin
+        @proc = Process.run(cmd_, arg_)
+      rescue ProcessError
+        STDERR.puts "ERROR: failed to run <#{@cmd}>"
+        return false
+      end
+      true
+    end
+
+    def pid; @proc.pid; end
+    def is_running?; @proc.is_running?; end
+    def exit_status; @proc.exitstatus; end
+
+    def wait(timeout, check_exit=true)
+      t = Time.now
+      begin
+        if @proc.check_status
+          if (Time.now() - t) >= timeout.to_f
+            STDERR.puts "ERROR: KILLING #{@cmd}"
+            @proc.kill
+            return 255
+          end
+          sleep(0.1)
+        end
+      end until !@proc.is_running?
+      if check_exit && @proc.has_error?
+        STDERR.puts "ERROR: #{@cmd} returned: #{@proc.exitstatus}"
+        return @proc.exitstatus != 0 ? @proc.exitstatus : 255
+      end
+      return 0
+    end
+
+    def wait_term(timeout)
+      @proc.stop
+      self.wait(timeout, false)
+    end
+
+    def kill(timeout)
+      @proc.kill
+      self.wait(timeout, false)
+    end
+
+  end
+
+  def TestUtil.wait_for_file(filename, timeout)
+    t = Time.now
+    while !File.readable?(filename) do
+      sleep(0.1)
+      if (Time.now() - t) >= timeout.to_f
+        STDERR.puts "ERROR: could not find file '#{filename}'"
+        return false
+      end
+    end
+    true
+  end
+
+  def TestUtil.remove_file(filename)
+    File.delete(filename) if File.exists?(filename)
+  end
+
+end
+