Class: Rex::Sync::Event

Inherits:
Object
  • Object
show all
Defined in:
lib/rex/sync/event.rb

Overview

This class wraps the logical ConditionVariable class to make it an easier to work with interface that is similar to Windows’ synchronization events.

Constant Summary collapse

Infinite = 
10000

Instance Method Summary collapse

Constructor Details

#initialize(state = false, auto_reset = true, param = nil) ⇒ Event

Initializes a waitable event. The state parameter initializes the default state of the event. If auto_reset is true, any calls to set() will automatically reset the event back to an unset state.



22
23
24
25
26
27
28
 
# File 'lib/rex/sync/event.rb', line 22

def initialize(state = false, auto_reset = true, param = nil)
  self.state      = state
  self.auto_reset = auto_reset
  self.param      = param
  self.mutex      = Mutex.new
  self.cond       = ConditionVariable.new
end

Instance Method Details

#reset ⇒ Object

Resets the signaled state to false.



50
51
52
53
 
# File 'lib/rex/sync/event.rb', line 50

def reset
  self.param = nil
  self.state = false
end

#set(param = nil) ⇒ Object Also known as: notify

Sets the event and wakes up anyone who was waiting.



33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/rex/sync/event.rb', line 33

def set(param = nil)
  self.param = param

  self.mutex.synchronize {
    # If this event does not automatically reset its state,
    # set the state to true
    if (auto_reset == false)
      self.state = true
    end

    self.cond.broadcast
  }
end

#wait(t = Infinite) ⇒ Object

Waits for the event to become signaled. Timeout is measured in seconds. Raises TimeoutError if the condition does not become signaled.



64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/rex/sync/event.rb', line 64

def wait(t = Infinite)
  self.mutex.synchronize {
    break if (self.state == true)

    Timeout.timeout(t) {
      self.cond.wait(self.mutex)
    }
  }

  return self.param
end