mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-20 03:42:52 +09:00
280 lines
7.6 KiB
Ruby
280 lines
7.6 KiB
Ruby
# -------------------------------------------------------------------------- */
|
|
# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org) #
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may */
|
|
# not use this file except in compliance with the License. You may obtain */
|
|
# a copy of the License at */
|
|
# */
|
|
# http://www.apache.org/licenses/LICENSE-2.0 */
|
|
# */
|
|
# Unless required by applicable law or agreed to in writing, software */
|
|
# distributed under the License is distributed on an "AS IS" BASIS, */
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
|
|
# See the License for the specific language governing permissions and */
|
|
# limitations under the License. */
|
|
# -------------------------------------------------------------------------- */
|
|
|
|
require 'thread'
|
|
|
|
=begin rdoc
|
|
Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)
|
|
|
|
This class provides support to handle actions. Class methods, or actions, can be
|
|
registered in the action manager. The manager will wait for actions to be
|
|
triggered (thread-safe), and will execute them concurrently. The action manager
|
|
can be used to synchronize different objects in different threads
|
|
|
|
== Example
|
|
|
|
class Sample
|
|
attr_reader :am
|
|
|
|
def initialize
|
|
@am = ActionManager.new(15,true)
|
|
|
|
@am.register_action("SLEEP",method("sleep_action"))
|
|
end
|
|
|
|
def sleep_action(secs)
|
|
sleep(secs)
|
|
end
|
|
|
|
def finalize_action
|
|
p "Exiting..."
|
|
@am.stop_listener
|
|
end
|
|
end
|
|
|
|
|
|
s = Sample.new
|
|
|
|
s.@am.start_listener
|
|
|
|
# Objects in other threads can trigger actions like this
|
|
# s.am.trigger_action("SLEEP",rand(3)+1)
|
|
# s.am.trigger_action("FINALIZE")
|
|
=end
|
|
|
|
class ActionManager
|
|
|
|
# Creates a new Action Manager
|
|
#
|
|
# +concurrency+ is the maximun number of actions that can run at the same
|
|
# time
|
|
# +threaded+ if true actions will be executed by default in a different
|
|
# thread
|
|
def initialize(concurrency=10, threaded=true)
|
|
@finalize = false
|
|
@actions = Hash.new
|
|
@threaded = threaded
|
|
|
|
@concurrency = concurrency
|
|
@num_running = 0
|
|
|
|
@action_queue = Array.new
|
|
@action_running = Hash.new
|
|
|
|
@threads_mutex = Mutex.new
|
|
@threads_cond = ConditionVariable.new
|
|
end
|
|
|
|
# Registers a new action in the manager. An action is defined by:
|
|
#
|
|
# +aname+ name of the action, it will identify the action
|
|
# +method+ it's invoked with call. It should be a Proc or Method object
|
|
# +threaded+ execute the action in a new thread
|
|
def register_action(aname, method, threaded=nil)
|
|
threaded ||= @threaded
|
|
|
|
@actions[aname]={
|
|
:method => method,
|
|
:threaded => threaded
|
|
}
|
|
end
|
|
|
|
# Triggers the execution of the action.
|
|
#
|
|
# +aname+ name of the action
|
|
# +action_id+ an id to identify the action (to cancel it later)
|
|
# +aargs+ arguments to call the action
|
|
def trigger_action(aname, action_id, *aargs)
|
|
|
|
@threads_mutex.synchronize {
|
|
return if @finalize
|
|
|
|
if aname == :FINALIZE
|
|
finalize if respond_to?(:finalize)
|
|
@finalize = true
|
|
@threads_cond.signal if @num_running == 0
|
|
return
|
|
end
|
|
|
|
if !@actions.has_key?(aname)
|
|
return
|
|
end
|
|
|
|
arity=@actions[aname][:method].arity
|
|
|
|
if arity < 0
|
|
# Last parameter is an array
|
|
arity = -arity - 1
|
|
if arity > aargs.length
|
|
# Message has not enough parameters
|
|
return
|
|
end
|
|
# Converts last parameters to an array
|
|
aargs[arity..-1]=[aargs[arity..-1]]
|
|
else
|
|
if arity != aargs.length
|
|
return
|
|
end
|
|
end
|
|
|
|
@action_queue << @actions[aname].merge(:args => aargs,
|
|
:id => action_id)
|
|
|
|
if @num_running < @concurrency
|
|
@threads_cond.signal
|
|
end
|
|
}
|
|
end
|
|
|
|
def cancel_action(action_id)
|
|
@threads_mutex.synchronize {
|
|
action = @action_running[action_id]
|
|
if action
|
|
thread = action[:thread]
|
|
else
|
|
thread = nil
|
|
end
|
|
|
|
if thread
|
|
thread.kill
|
|
|
|
@num_running -= 1
|
|
delete_running_action(action_id)
|
|
|
|
@threads_cond.signal
|
|
else
|
|
i = @action_queue.select{|x| x[:id] == action_id}.first
|
|
@action_queue.delete(i) if i
|
|
end
|
|
}
|
|
end
|
|
|
|
def start_listener
|
|
while true
|
|
@threads_mutex.synchronize {
|
|
while ((@concurrency - @num_running)==0) || empty_queue
|
|
@threads_cond.wait(@threads_mutex)
|
|
|
|
return if (@finalize && @num_running == 0)
|
|
end
|
|
|
|
run_action
|
|
}
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def delete_running_action(action_id)
|
|
@action_running.delete(action_id)
|
|
end
|
|
|
|
def get_runable_action
|
|
@action_queue.shift
|
|
end
|
|
|
|
def empty_queue
|
|
@action_queue.size==0
|
|
end
|
|
|
|
def run_action
|
|
action = get_runable_action
|
|
|
|
if action
|
|
@num_running += 1
|
|
|
|
if action[:threaded]
|
|
thread = Thread.new {
|
|
action[:method].call(*action[:args])
|
|
|
|
@threads_mutex.synchronize {
|
|
@num_running -= 1
|
|
delete_running_action(action[:id])
|
|
|
|
@threads_cond.signal
|
|
}
|
|
}
|
|
|
|
action[:thread] = thread
|
|
@action_running[action[:id]] = action
|
|
else
|
|
action[:method].call(*action[:args])
|
|
|
|
@num_running -= 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if __FILE__ == $0
|
|
|
|
class Sample
|
|
attr_reader :am
|
|
|
|
def initialize
|
|
@am = ActionManager.new(15,true)
|
|
|
|
@am.register_action(:SLEEP,method("sleep_action"))
|
|
# @am.register_action(:SLEEP,Proc.new{|s,i| p s ; sleep(s)})
|
|
@am.register_action(:NOP,method("nop_action"))
|
|
|
|
def @am.get_runable_action
|
|
action = super
|
|
puts "getting: #{action.inspect}"
|
|
action
|
|
end
|
|
|
|
def @am.delete_running_action(action_id)
|
|
puts "deleting: #{action_id}"
|
|
super(action_id)
|
|
end
|
|
end
|
|
|
|
def sleep_action(secs, id)
|
|
p "ID: #{id} sleeping #{secs} seconds"
|
|
sleep(secs)
|
|
p "ID: #{id} Awaken!"
|
|
end
|
|
|
|
def nop_action
|
|
p " - Just an action"
|
|
end
|
|
|
|
end
|
|
|
|
s = Sample.new
|
|
|
|
Thread.new {
|
|
sleep 1
|
|
|
|
100.times {|n|
|
|
s.am.trigger_action(:SLEEP,n,rand(3)+1,n)
|
|
s.am.trigger_action(:NOP,100+n)
|
|
}
|
|
|
|
s.am.trigger_action(:SLEEP,301,5,301)
|
|
|
|
s.am.cancel_action(301)
|
|
|
|
s.am.trigger_action(:FINALIZE,0)
|
|
|
|
s.am.trigger_action(:SLEEP,999,rand(3)+1,999)
|
|
s.am.trigger_action(:SLEEP,333,rand(3)+1,333)
|
|
}
|
|
|
|
s.am.start_listener
|
|
end
|
|
|