Class: Ice::CtrlCHandler

Inherits:

Object

• Object
• Ice::CtrlCHandler

Defined in:

lib/Ice.rb

Overview

Note the interface is the same as the C++ CtrlCHandler implementation, however, the implementation is different.

Constant Summary

@@_self =

nil

Instance Method Summary

• #destroy ⇒ Object

  Destroy the object.

• #getCallback ⇒ Object
• #initialize ⇒ CtrlCHandler constructor

  A new instance of CtrlCHandler.

• #main ⇒ Object

  Dequeue and dispatch signals.

• #setCallback(callback) ⇒ Object
• #signalHandler(sig) ⇒ Object

  Private.

Constructor Details

#initialize ⇒ CtrlCHandler

Returns a new instance of CtrlCHandler.

# File 'lib/Ice.rb', line 245

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

Instance Method Details

#destroy ⇒ Object

Destroy the object. Wait for the thread to terminate and cleanup the internal state.

# File 'lib/Ice.rb', line 290

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

#getCallback ⇒ Object

# File 'lib/Ice.rb', line 316

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

#main ⇒ Object

Dequeue and dispatch signals.

# File 'lib/Ice.rb', line 271

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

#setCallback(callback) ⇒ Object

# File 'lib/Ice.rb', line 310

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

#signalHandler(sig) ⇒ Object

Private. Only called by the signal handling mechanism.

# File 'lib/Ice.rb', line 323

def signalHandler(sig)
    @mutex.synchronize {
        #
        # The signal AND the current callback are queued together.
        #
        @queue = @queue.push([sig, @callback])
        @condVar.signal
    }
end