path: root/rb/ruby/Ice.rb

# **********************************************************************
#
# Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************

require 'IceRuby'
require 'thread'

module Ice

    #
    # Convenience function for locating the directory containing the
    # Slice files.
    #
    def Ice.getSliceDir
        #
        # Get the parent of the directory containing this file
        # (Ice.rb).
        #
        rbHome = File::join(File::dirname(__FILE__), "..")

        #
        # For an installation from a source distribution, a binary
        # tarball, or a Windows installer, the "slice" directory is a
        # sibling of the "rb" directory.
        #
        dir = File::join(rbHome, "slice")
        if File::exists?(dir)
            return File::expand_path(dir)
        end

        #
        # In a source distribution, the "slice" directory is one level
        # higher.
        #
        dir = File::join(rbHome, "..", "slice")
        if File::exists?(dir)
            return File::expand_path(dir)
        end

        if RUBY_PLATFORM =~ /linux/i
            iceVer = Ice::stringVersion
            #
            # Check the default RPM location.
            #
            dir = File::join("/", "usr", "share", "Ice-" + iceVer, "slice")
            if File::exists?(dir)
                return dir
            end
        end

        return nil
    end

    #
    # Exceptions.
    #
    class Exception < ::StandardError
        def ice_name
            to_s
        end

        def inspect
            return ::Ice::__stringifyException(self)
        end
    end

    class UserException < Exception
    end

    class LocalException < Exception
    end

    #
    # Object.
    #
    T_Object = Ice.__declareClass('::Ice::Object')
    T_ObjectPrx = Ice.__declareProxy('::Ice::Object')

    module Object_mixin
        def ice_isA(id, current=nil)
            return ice_ids().include?(id)
        end

        def ice_ping(current=nil)
        end
    end

    class Object
        include Object_mixin

        def Object.ice_staticId()
            '::Ice::Object'
        end
    end

    T_Object.defineClass(nil, true, nil, [], [])
    Object_mixin::ICE_TYPE = T_Object

    T_ObjectPrx.defineProxy(ObjectPrx, T_Object)
    ObjectPrx::ICE_TYPE = T_ObjectPrx

    #
    # LocalObject.
    #
    T_LocalObject = Ice.__declareLocalClass('::Ice::LocalObject')
    T_LocalObject.defineClass(nil, true, nil, [], [])

    #
    # InitializationData.
    #
    class InitializationData
        def initialize(properties=nil, logger=nil)
            @properties = properties
            @logger = logger
        end

        attr_accessor :properties, :logger
    end

    #
    # Slice checksum dictionary.
    #
    SliceChecksums = {}
end

#
# Include certain generated files.
#
require 'Ice/BuiltinSequences.rb'
require 'Ice/Current.rb'
require 'Ice/EndpointTypes.rb'
require 'Ice/LocalException.rb'
require 'Ice/Locator.rb'
require 'Ice/Logger.rb'
require 'Ice/ObjectFactory.rb'
require 'Ice/Process.rb'
require 'Ice/Router.rb'
require 'Ice/Endpoint.rb'

module Ice
    #
    # Reopen Identity to add the <=> method.
    #
    class Identity
        def <=>(other)
            n = self.name <=> other.name
            if n == 0
                return self.category <=> other.category
            else
                return n
            end
        end
    end

    #
    # Note the interface is the same as the C++ CtrlCHandler
    # implementation, however, the implementation is different.
    #
    class CtrlCHandler
        def initialize
            if @@_self != nil
                raise RuntimeError, "Only a single instance of a CtrlCHandler can be instantiated."
            end
            @@_self = self

            # State variables. These are not class static variables.
            @condVar = ConditionVariable.new
            @mutex = Mutex.new
            @queue = Array.new
            @done = false
            @callback = nil

            #
            # Setup and install signal handlers
            #
            if Signal.list.has_key?('HUP')
                Signal.trap('HUP') { signalHandler('HUP') }
            end
            Signal.trap('INT') { signalHandler('INT') }
            Signal.trap('TERM') { signalHandler('TERM') }

            @thr = Thread.new { main }
        end

        # Dequeue and dispatch signals.
        def main
            while true
                sig, callback = @mutex.synchronize {
                    while @queue.empty? and not @done
                        @condVar.wait(@mutex)
                    end
                    if @done
                        return
                    end
                    @queue.shift
                }
                if callback
                    callback.call(sig)
                end
            end
        end

        # Destroy the object. Wait for the thread to terminate and cleanup
        # the internal state.
        def destroy
            @mutex.synchronize {
                @done = true
                @condVar.signal
            }

            # Wait for the thread to terminate
            @thr.join

            #
            # Cleanup any state set by the CtrlCHandler.
            #
            if Signal.list.has_key?('HUP')
                Signal.trap('HUP', 'SIG_DFL')
            end
            Signal.trap('INT', 'SIG_DFL')
            Signal.trap('TERM', 'SIG_DFL')
            @@_self = nil
        end

        def setCallback(callback)
            @mutex.synchronize {
                @callback = callback
            }
        end

        def getCallback
            @mutex.synchronize {
                return @callback
            }
        end

        # Private. Only called by the signal handling mechanism.
        def signalHandler(sig)
            @mutex.synchronize {
                #
                # The signal AND the current callback are queued together.
                #
                @queue = @queue.push([sig, @callback])
                @condVar.signal
            }
        end
        @@_self = nil
    end

    #
    # Ice::Application.
    #
    class Application
        def initialize(signalPolicy=HandleSignals)
            @@_signalPolicy = signalPolicy
        end
        
        def main(args, configFile=nil, initData=nil)
            if @@_communicator
                Ice::getProcessLogger().error($0 + ": only one instance of the Application class can be used")
                return false
            end
            if @@_signalPolicy == HandleSignals
                @@_ctrlCHandler = CtrlCHandler.new
            end

            @@_interrupted = false
            @@_appName = $0

            status = 0

            begin
                if initData.nil?
                    initData = InitializationData.new
                end
                if configFile
                    initData.properties = Ice::createProperties
                    initData.properties.load(configFile)
                end
                initData.properties = Ice::createProperties(args, initData.properties)

                @@_application = self
                @@_communicator = Ice::initialize(args, initData)
                @@_destroyed = false

                #
                # Used by destroyOnInterruptCallback.
                #
                @@_nohup = @@_communicator.getProperties().getPropertyAsInt("Ice.Nohup") > 0

                #
                # The default is to destroy when a signal is received.
                #
                if @@_signalPolicy == HandleSignals
                    Application::destroyOnInterrupt
                end

                status = run(args)
            rescue => ex
                Ice::getProcessLogger().error($!.inspect + "\n" + ex.backtrace.join("\n"))
                status = 1
            end

            #
            # Don't want any new interrupt and at this point (post-run),
            # it would not make sense to release a held signal to run
            # shutdown or destroy.
            #
            if @@_signalPolicy == HandleSignals
                Application::ignoreInterrupt
            end

            @@_mutex.synchronize {
                while @@_callbackInProgress
                    @@_condVar.wait(@@_mutex)
                end
                if @@_destroyed
                    @@_communicator = nil
                else
                    @@_destroyed = true
                end
                #
                # And _communicator != 0, meaning will be destroyed
                # next, _destroyed = true also ensures that any
                # remaining callback won't do anything
                #
                @@_application = nil
            }

            if @@_communicator
                begin
                    @@_communicator.destroy()
                rescue => ex
                    Ice::getProcessLogger().error($!.inspect + "\n" + ex.backtrace.join("\n"))
                    status = 1
                end

                @@_communicator = nil
            end

            if @@_signalPolicy == HandleSignals
                @@_ctrlCHandler.destroy()
                @@_ctrlCHandler = nil
            end

            return status
        end

        def interruptCallback(sig)
        end

        def Application.appName
            @@_appName
        end

        def Application.communicator
            @@_communicator
        end

        def Application.destroyOnInterrupt
            if @@_signalPolicy == HandleSignals
                @@_mutex.synchronize {
                    if @@_ctrlCHandler.getCallback == @@_holdInterruptCallbackProc
                        @@_released = true
                        @@_condVar.signal
                    end
                    @@_ctrlCHandler.setCallback(@@_destroyOnInterruptCallbackProc)
                }
            else
                Ice::getProcessLogger().error(@@_appName + ": warning: interrupt method called on Application configured to not handle interrupts.")
            end
        end

        # No support for this since no server side in Ice for ruby.
        #def Application.shutdownOnInterrupt
        #end

        def Application.ignoreInterrupt
            if @@_signalPolicy == HandleSignals
                @@_mutex.synchronize {
                    if @@_ctrlCHandler.getCallback == @@_holdInterruptCallbackProc
                        @@_released = true
                        @@_condVar.signal
                    end
                    @@_ctrlCHandler.setCallback(nil)
                }
            else
                Ice::getProcessLogger().error(@@_appName + ": warning: interrupt method called on Application configured to not handle interrupts.")
            end
        end

        def Application.callbackOnInterrupt()
            if @@_signalPolicy == HandleSignals
                @@_mutex.synchronize {
                    if @@_ctrlCHandler.getCallback == @@_holdInterruptCallbackProc
                        @@_released = true
                        @@_condVar.signal
                    end
                    @@_ctrlCHandler.setCallback(@@_callbackOnInterruptCallbackProc)
                }
            else
                Ice::getProcessLogger().error(@@_appName + ": warning: interrupt method called on Application configured to not handle interrupts.")
            end
        end

        def Application.holdInterrupt
            if @@_signalPolicy == HandleSignals
                @@_mutex.synchronize {
                    if @@_ctrlCHandler.getCallback != @@_holdInterruptCallbackProc
                        @@_previousCallback = @@_ctrlCHandler.getCallback
                        @@_released = false
                        @@_ctrlCHandler.setCallback(@@_holdInterruptCallbackProc)
                    end
                    # else, we were already holding signals
                }
            else
                Ice::getProcessLogger().error(@@_appName + ": warning: interrupt method called on Application configured to not handle interrupts.")
            end
        end

        def Application.releaseInterrupt
            if @@_signalPolicy == HandleSignals
                @@_mutex.synchronize {
                    if @@_ctrlCHandler.getCallback == @@_holdInterruptCallbackProc
                        #
                        # Note that it's very possible no signal is held;
                        # in this case the callback is just replaced and
                        # setting _released to true and signalling _condVar
                        # do no harm.
                        #
                        @@_released = true
                        @@_ctrlCHandler.setCallback(@@_previousCallback)
                        @@_condVar.signal
                    end
                    # Else nothing to release.
                }
            else
                Ice::getProcessLogger().error(@@_appName + ": warning: interrupt method called on Application configured to not handle interrupts.")
            end
        end

        def Application.interrupted
            @@_mutex.synchronize {
                return @@_interrupted
            }
        end

        def Application.holdInterruptCallback(sig)
            callback = @@_mutex.synchronize {
                while not @@_released
                    @@_condVar.wait(@@_mutex)
                end
                if @@_destroyed
                    return
                end
                @@_ctrlCHandler.getCallback
            }

            #
            # Use the current callback to process this (old) signal.
            #
            if callback
                callback.call(sig)
            end
        end

        def Application.destroyOnInterruptCallback(sig)
            @@_mutex.synchronize {
                if @@_destroyed or @@_nohup and sig == 'HUP'
                    return
                end
                @@_callbackInProcess = true
                @@_interrupted = true
                @@_destroyed = true
            }

            begin
                @@_communicator.destroy()
            rescue => ex
                Ice::getProcessLogger().error($!.inspect + "\n" + @@_appName + " (while destroying in response to signal " + sig + "):\n" + ex.backtrace.join("\n"))
            end
            @@_mutex.synchronize {
                @@_callbackInProcess = false
                @@_condVar.signal
            }
        end

        def Application.callbackOnInterruptCallback(sig)
            # For SIGHUP the user callback is always called. It can
            # decide what to do.
            @@_mutex.synchronize {
                if @@_destroyed
                    #
                    # Being destroyed by main thread.
                    #
                    return
                end
                @@_interrupted = true
                @@_callbackInProcess = true
            }

            begin
                @@_application.interruptCallback(sig)
            rescue => ex
                Ice::getProcessLogger().error($!.inspect + "\n" + @@_appName + " (while interrupting in response to signal " + sig + "):\n" + ex.backtrace.join("\n"))
            end
            @@_mutex.synchronize {
                @@_callbackInProcess = false
                @@_condVar.signal
            }
        end

        HandleSignals = 0
        NoSignalHandling = 1

        @@_appName = nil
        @@_communicator = nil
        @@_application = nil
        @@_ctrlCHandler = nil
        @@_previousCallback = nil
        @@_interrupted = false
        @@_released = false
        @@_destroyed = false
        @@_callbackInProgress = false
        @@_condVar = ConditionVariable.new
        @@_mutex = Mutex.new
        @@_holdInterruptCallbackProc = Proc.new { |sig| Application::holdInterruptCallback(sig) }
        @@_destroyOnInterruptCallbackProc = Proc.new { |sig| Application::destroyOnInterruptCallback(sig) }
        @@_callbackOnInterruptCallbackProc = Proc.new { |sig| Application::callbackOnInterruptCallback(sig) }
        @@_signalPolicy = HandleSignals
    end

    #
    # Proxy comparison functions.
    #
    def Ice.proxyIdentityCompare(lhs, rhs)
        if (lhs && !lhs.is_a?(ObjectPrx)) || (rhs && !rhs.is_a?(ObjectPrx))
            raise TypeError, 'argument is not a proxy'
        end
        if lhs.nil? && rhs.nil?
            return 0
        elsif lhs.nil? && rhs
            return -1
        elsif lhs && rhs.nil?
            return 1
        else
            return lhs.ice_getIdentity() <=> rhs.ice_getIdentity()
        end
    end

    def Ice.proxyIdentityEqual(lhs, rhs)
        return proxyIdentityCompare(lhs, rhs) == 0
    end

    def Ice.proxyIdentityAndFacetCompare(lhs, rhs)
        n = proxyIdentityCompare(lhs, rhs)
        if n == 0 && lhs && rhs
            n = lhs.ice_getFacet() <=> rhs.ice_getFacet()
        end
        return n
    end

    def Ice.proxyIdentityAndFacetEqual(lhs, rhs)
        return proxyIdentityAndFacetCompare(lhs, rhs) == 0
    end
end

Ice::Object_mixin::OP_ice_isA = ::Ice::__defineOperation('ice_isA', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, [::Ice::T_string], [], ::Ice::T_bool, [])
Ice::Object_mixin::OP_ice_ping = ::Ice::__defineOperation('ice_ping', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, [], [], nil, [])
Ice::Object_mixin::OP_ice_ids = ::Ice::__defineOperation('ice_ids', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, [], [], ::Ice::T_StringSeq, [])
Ice::Object_mixin::OP_ice_id = ::Ice::__defineOperation('ice_id', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, [], [], ::Ice::T_string, [])